forked from OSchip/llvm-project
[flang][NFC] Fix lowering tests indent
Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
This commit is contained in:
Valentin Clement
parent
71b162c4bd
commit
2985d1c267
|
|
@ -10,63 +10,63 @@
|
|||
! CHECK: fir.has_value %[[modcInitBox]] : !fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>
|
||||
|
||||
module mod_allocatables
|
||||
character(10), allocatable :: c(:)
|
||||
end module
|
||||
character(10), allocatable :: c(:)
|
||||
end module
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_mod_allocatables()
|
||||
subroutine test_mod_allocatables()
|
||||
use mod_allocatables, only: c
|
||||
! CHECK: fir.address_of(@_QMmod_allocatablesEc) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>>
|
||||
call bar(c(1))
|
||||
end subroutine
|
||||
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_globals()
|
||||
subroutine test_globals()
|
||||
integer, allocatable :: gx, gy(:, :)
|
||||
save :: gx, gy
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgx) : !fir.ref<!fir.box<!fir.heap<i32>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgy) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
character(:), allocatable :: gc1, gc2(:, :)
|
||||
character(10), allocatable :: gc3, gc4(:, :)
|
||||
save :: gc1, gc2, gc3, gc4
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc1) : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc2) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc3) : !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc4) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>>
|
||||
allocate(gx, gy(20, 30), gc3, gc4(40, 50))
|
||||
allocate(character(15):: gc1, gc2(60, 70))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc1 : !fir.box<!fir.heap<!fir.char<1,?>>>
|
||||
! CHECK-DAG: %[[gc1NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.char<1,?>>
|
||||
! CHECK: %[[gc1InitBox:.*]] = fir.embox %[[gc1NullAddr]] typeparams %c0{{.*}} : (!fir.heap<!fir.char<1,?>>, index) -> !fir.box<!fir.heap<!fir.char<1,?>>>
|
||||
! CHECK: fir.has_value %[[gc1InitBox]] : !fir.box<!fir.heap<!fir.char<1,?>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc2 : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
! CHECK-DAG: %[[gc2NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?x!fir.char<1,?>>>
|
||||
! CHECK-DAG: %[[gc2NullShape:.*]] = fir.shape %c0{{.*}}, %c0{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[gc2InitBox:.*]] = fir.embox %[[gc2NullAddr]](%[[gc2NullShape]]) typeparams %c0{{.*}} : (!fir.heap<!fir.array<?x?x!fir.char<1,?>>>, !fir.shape<2>, index) -> !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.has_value %[[gc2InitBox]] : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc3 : !fir.box<!fir.heap<!fir.char<1,10>>>
|
||||
! CHECK-DAG: %[[gc3NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.char<1,10>>
|
||||
! CHECK: %[[gc3InitBox:.*]] = fir.embox %[[gc3NullAddr]] : (!fir.heap<!fir.char<1,10>>) -> !fir.box<!fir.heap<!fir.char<1,10>>>
|
||||
! CHECK: fir.has_value %[[gc3InitBox]] : !fir.box<!fir.heap<!fir.char<1,10>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc4 : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>
|
||||
! CHECK-DAG: %[[gc4NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?x!fir.char<1,10>>>
|
||||
! CHECK-DAG: %[[gc4NullShape:.*]] = fir.shape %c0{{.*}}, %c0{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[gc4InitBox:.*]] = fir.embox %[[gc4NullAddr]](%[[gc4NullShape]]) : (!fir.heap<!fir.array<?x?x!fir.char<1,10>>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>
|
||||
! CHECK: fir.has_value %[[gc4InitBox]] : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgx : !fir.box<!fir.heap<i32>>
|
||||
! CHECK: %[[gxNullAddr:.*]] = fir.zero_bits !fir.heap<i32>
|
||||
! CHECK: %[[gxInitBox:.*]] = fir.embox %0 : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>
|
||||
! CHECK: fir.has_value %[[gxInitBox]] : !fir.box<!fir.heap<i32>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgy : !fir.box<!fir.heap<!fir.array<?x?xi32>>> {
|
||||
! CHECK-DAG: %[[gyNullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK-DAG: %[[gyShape:.*]] = fir.shape %c0{{.*}}, %c0{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[gyInitBox:.*]] = fir.embox %[[gyNullAddr]](%[[gyShape]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK: fir.has_value %[[gyInitBox]] : !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-LABEL: func @_QPtest_mod_allocatables()
|
||||
subroutine test_mod_allocatables()
|
||||
use mod_allocatables, only: c
|
||||
! CHECK: fir.address_of(@_QMmod_allocatablesEc) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>>
|
||||
call bar(c(1))
|
||||
end subroutine
|
||||
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_globals()
|
||||
subroutine test_globals()
|
||||
integer, allocatable :: gx, gy(:, :)
|
||||
save :: gx, gy
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgx) : !fir.ref<!fir.box<!fir.heap<i32>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgy) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
character(:), allocatable :: gc1, gc2(:, :)
|
||||
character(10), allocatable :: gc3, gc4(:, :)
|
||||
save :: gc1, gc2, gc3, gc4
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc1) : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc2) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc3) : !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>>
|
||||
! CHECK-DAG: fir.address_of(@_QFtest_globalsEgc4) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>>
|
||||
allocate(gx, gy(20, 30), gc3, gc4(40, 50))
|
||||
allocate(character(15):: gc1, gc2(60, 70))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc1 : !fir.box<!fir.heap<!fir.char<1,?>>>
|
||||
! CHECK-DAG: %[[gc1NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.char<1,?>>
|
||||
! CHECK: %[[gc1InitBox:.*]] = fir.embox %[[gc1NullAddr]] typeparams %c0{{.*}} : (!fir.heap<!fir.char<1,?>>, index) -> !fir.box<!fir.heap<!fir.char<1,?>>>
|
||||
! CHECK: fir.has_value %[[gc1InitBox]] : !fir.box<!fir.heap<!fir.char<1,?>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc2 : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
! CHECK-DAG: %[[gc2NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?x!fir.char<1,?>>>
|
||||
! CHECK-DAG: %[[gc2NullShape:.*]] = fir.shape %c0{{.*}}, %c0{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[gc2InitBox:.*]] = fir.embox %[[gc2NullAddr]](%[[gc2NullShape]]) typeparams %c0{{.*}} : (!fir.heap<!fir.array<?x?x!fir.char<1,?>>>, !fir.shape<2>, index) -> !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.has_value %[[gc2InitBox]] : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc3 : !fir.box<!fir.heap<!fir.char<1,10>>>
|
||||
! CHECK-DAG: %[[gc3NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.char<1,10>>
|
||||
! CHECK: %[[gc3InitBox:.*]] = fir.embox %[[gc3NullAddr]] : (!fir.heap<!fir.char<1,10>>) -> !fir.box<!fir.heap<!fir.char<1,10>>>
|
||||
! CHECK: fir.has_value %[[gc3InitBox]] : !fir.box<!fir.heap<!fir.char<1,10>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgc4 : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>
|
||||
! CHECK-DAG: %[[gc4NullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?x!fir.char<1,10>>>
|
||||
! CHECK-DAG: %[[gc4NullShape:.*]] = fir.shape %c0{{.*}}, %c0{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[gc4InitBox:.*]] = fir.embox %[[gc4NullAddr]](%[[gc4NullShape]]) : (!fir.heap<!fir.array<?x?x!fir.char<1,10>>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>
|
||||
! CHECK: fir.has_value %[[gc4InitBox]] : !fir.box<!fir.heap<!fir.array<?x?x!fir.char<1,10>>>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgx : !fir.box<!fir.heap<i32>>
|
||||
! CHECK: %[[gxNullAddr:.*]] = fir.zero_bits !fir.heap<i32>
|
||||
! CHECK: %[[gxInitBox:.*]] = fir.embox %0 : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>
|
||||
! CHECK: fir.has_value %[[gxInitBox]] : !fir.box<!fir.heap<i32>>
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFtest_globalsEgy : !fir.box<!fir.heap<!fir.array<?x?xi32>>> {
|
||||
! CHECK-DAG: %[[gyNullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK-DAG: %[[gyShape:.*]] = fir.shape %c0{{.*}}, %c0{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[gyInitBox:.*]] = fir.embox %[[gyNullAddr]](%[[gyShape]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK: fir.has_value %[[gyInitBox]] : !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
|
|
|
|||
|
|
@ -2,48 +2,48 @@
|
|||
|
||||
! CHECK-LABEL: func @_QPss
|
||||
subroutine ss(n)
|
||||
print*, n
|
||||
! CHECK: return{{$}}
|
||||
return
|
||||
! CHECK-LABEL: func @_QPee
|
||||
entry ee(n,*)
|
||||
print*, n
|
||||
! CHECK: return %{{.}} : index
|
||||
return 1
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QQmain
|
||||
call ss(7)
|
||||
call ee(2, *3)
|
||||
print*, 'default'
|
||||
3 print*, 3
|
||||
|
||||
print*, k(10,20)
|
||||
print*, k(15,15)
|
||||
print*, k(20,10)
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPk
|
||||
function k(n1, n2)
|
||||
! CHECK-NOT: ^bb
|
||||
! CHECK: [[selector:%[0-9]+]] = fir.call @_QPs
|
||||
! CHECK-NEXT: fir.select [[selector]] : index [1, ^[[block1:bb[0-9]+]], 2, ^[[block2:bb[0-9]+]], unit, ^[[blockunit:bb[0-9]+]]
|
||||
call s(n1, *5, n2, *7)
|
||||
! CHECK: ^[[blockunit]]: // pred: ^bb0
|
||||
k = 0; return;
|
||||
! CHECK: ^[[block1]]: // pred: ^bb0
|
||||
5 k = -1; return;
|
||||
! CHECK: ^[[block2]]: // pred: ^bb0
|
||||
7 k = 1; return
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPs
|
||||
subroutine s(n1, *, n2, *)
|
||||
! CHECK: [[retval:%[0-9]+]] = fir.alloca index {{{.*}}bindc_name = "s"}
|
||||
! CHECK-COUNT-3: fir.store {{.*}} to [[retval]] : !fir.ref<index>
|
||||
if (n1 < n2) return 1
|
||||
if (n1 > n2) return 2
|
||||
! CHECK: {{.*}} = fir.load [[retval]] : !fir.ref<index>
|
||||
! CHECK-NEXT: return {{.*}} : index
|
||||
return
|
||||
end
|
||||
print*, n
|
||||
! CHECK: return{{$}}
|
||||
return
|
||||
! CHECK-LABEL: func @_QPee
|
||||
entry ee(n,*)
|
||||
print*, n
|
||||
! CHECK: return %{{.}} : index
|
||||
return 1
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QQmain
|
||||
call ss(7)
|
||||
call ee(2, *3)
|
||||
print*, 'default'
|
||||
3 print*, 3
|
||||
|
||||
print*, k(10,20)
|
||||
print*, k(15,15)
|
||||
print*, k(20,10)
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPk
|
||||
function k(n1, n2)
|
||||
! CHECK-NOT: ^bb
|
||||
! CHECK: [[selector:%[0-9]+]] = fir.call @_QPs
|
||||
! CHECK-NEXT: fir.select [[selector]] : index [1, ^[[block1:bb[0-9]+]], 2, ^[[block2:bb[0-9]+]], unit, ^[[blockunit:bb[0-9]+]]
|
||||
call s(n1, *5, n2, *7)
|
||||
! CHECK: ^[[blockunit]]: // pred: ^bb0
|
||||
k = 0; return;
|
||||
! CHECK: ^[[block1]]: // pred: ^bb0
|
||||
5 k = -1; return;
|
||||
! CHECK: ^[[block2]]: // pred: ^bb0
|
||||
7 k = 1; return
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPs
|
||||
subroutine s(n1, *, n2, *)
|
||||
! CHECK: [[retval:%[0-9]+]] = fir.alloca index {{{.*}}bindc_name = "s"}
|
||||
! CHECK-COUNT-3: fir.store {{.*}} to [[retval]] : !fir.ref<index>
|
||||
if (n1 < n2) return 1
|
||||
if (n1 > n2) return 2
|
||||
! CHECK: {{.*}} = fir.load [[retval]] : !fir.ref<index>
|
||||
! CHECK-NEXT: return {{.*}} : index
|
||||
return
|
||||
end
|
||||
|
|
|
|||
|
|
@ -2,36 +2,36 @@
|
|||
|
||||
! CHECK-LABEL: func @_QPkagi
|
||||
function kagi(index)
|
||||
! CHECK: fir.select_case %{{.}} : i32 [#fir.upper, %c-1_i32, ^bb{{.}}, #fir.lower, %c1_i32, ^bb{{.}}, unit, ^bb{{.}}]
|
||||
if (index) 7, 8, 9
|
||||
kagi = 0; return
|
||||
7 kagi = 1; return
|
||||
8 kagi = 2; return
|
||||
9 kagi = 3; return
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPkagf
|
||||
function kagf(findex)
|
||||
! CHECK: %[[zero:.+]] = arith.constant 0.0
|
||||
! CHECK: %{{.+}} = arith.cmpf olt, %{{.+}}, %[[zero]] : f32
|
||||
! CHECK: cond_br %
|
||||
! CHECK: %{{.+}} = arith.cmpf ogt, %{{.+}}, %[[zero]] : f32
|
||||
! CHECK: cond_br %
|
||||
! CHECK: br ^
|
||||
if (findex+findex) 7, 8, 9
|
||||
kagf = 0; return
|
||||
7 kagf = 1; return
|
||||
8 kagf = 2; return
|
||||
9 kagf = 3; return
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QQmain
|
||||
|
||||
print*, kagf(-2.0)
|
||||
print*, kagf(-1.0)
|
||||
print*, kagf(-0.0)
|
||||
print*, kagf( 0.0)
|
||||
print*, kagf(+0.0)
|
||||
print*, kagf(+1.0)
|
||||
print*, kagf(+2.0)
|
||||
end
|
||||
! CHECK: fir.select_case %{{.}} : i32 [#fir.upper, %c-1_i32, ^bb{{.}}, #fir.lower, %c1_i32, ^bb{{.}}, unit, ^bb{{.}}]
|
||||
if (index) 7, 8, 9
|
||||
kagi = 0; return
|
||||
7 kagi = 1; return
|
||||
8 kagi = 2; return
|
||||
9 kagi = 3; return
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPkagf
|
||||
function kagf(findex)
|
||||
! CHECK: %[[zero:.+]] = arith.constant 0.0
|
||||
! CHECK: %{{.+}} = arith.cmpf olt, %{{.+}}, %[[zero]] : f32
|
||||
! CHECK: cond_br %
|
||||
! CHECK: %{{.+}} = arith.cmpf ogt, %{{.+}}, %[[zero]] : f32
|
||||
! CHECK: cond_br %
|
||||
! CHECK: br ^
|
||||
if (findex+findex) 7, 8, 9
|
||||
kagf = 0; return
|
||||
7 kagf = 1; return
|
||||
8 kagf = 2; return
|
||||
9 kagf = 3; return
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QQmain
|
||||
|
||||
print*, kagf(-2.0)
|
||||
print*, kagf(-1.0)
|
||||
print*, kagf(-0.0)
|
||||
print*, kagf( 0.0)
|
||||
print*, kagf(+0.0)
|
||||
print*, kagf(+1.0)
|
||||
print*, kagf(+2.0)
|
||||
end
|
||||
|
|
|
|||
|
|
@ -3,171 +3,171 @@
|
|||
! CHECK-LABEL: func @_QPissue(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) {
|
||||
subroutine issue(c1, c2)
|
||||
! CHECK-DAG: %[[VAL_2:.*]] = arith.constant false
|
||||
! CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : i8
|
||||
! CHECK-DAG: %[[VAL_4:.*]] = arith.constant 3 : index
|
||||
! CHECK-DAG: %[[VAL_5:.*]] = arith.constant 4 : index
|
||||
! CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
|
||||
! CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_8:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_10:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<3x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
|
||||
! CHECK: cf.br ^bb1(%[[VAL_6]], %[[VAL_4]] : index, index)
|
||||
! CHECK: ^bb1(%[[VAL_13:.*]]: index, %[[VAL_14:.*]]: index):
|
||||
! CHECK: %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_14]], %[[VAL_6]] : index
|
||||
! CHECK: cf.cond_br %[[VAL_15]], ^bb2, ^bb6
|
||||
! CHECK: ^bb2:
|
||||
! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_13]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_16]] typeparams %[[VAL_10]]#1 : (!fir.ref<!fir.array<3x!fir.char<1,?>>>, !fir.shape<1>, index, index) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_18:.*]] = fir.array_coor %[[VAL_9]](%[[VAL_12]]) %[[VAL_16]] : (!fir.ref<!fir.array<3x!fir.char<1,4>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,4>>
|
||||
! CHECK: %[[VAL_19:.*]] = arith.cmpi slt, %[[VAL_5]], %[[VAL_10]]#1 : index
|
||||
! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_5]], %[[VAL_10]]#1 : index
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (index) -> i64
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_17]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_22]], %[[VAL_23]], %[[VAL_21]], %[[VAL_2]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_24:.*]] = fir.undefined !fir.char<1>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[VAL_3]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
|
||||
! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_5]], %[[VAL_20]] : index
|
||||
! CHECK: cf.br ^bb3(%[[VAL_20]], %[[VAL_26]] : index, index)
|
||||
! CHECK: ^bb3(%[[VAL_27:.*]]: index, %[[VAL_28:.*]]: index):
|
||||
! CHECK: %[[VAL_29:.*]] = arith.cmpi sgt, %[[VAL_28]], %[[VAL_6]] : index
|
||||
! CHECK: cf.cond_br %[[VAL_29]], ^bb4, ^bb5
|
||||
! CHECK: ^bb4:
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<!fir.array<4x!fir.char<1>>>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_30]], %[[VAL_27]] : (!fir.ref<!fir.array<4x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
|
||||
! CHECK: fir.store %[[VAL_25]] to %[[VAL_31]] : !fir.ref<!fir.char<1>>
|
||||
! CHECK: %[[VAL_32:.*]] = arith.addi %[[VAL_27]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_28]], %[[VAL_7]] : index
|
||||
! CHECK: cf.br ^bb3(%[[VAL_32]], %[[VAL_33]] : index, index)
|
||||
! CHECK: ^bb5:
|
||||
! CHECK-DAG: %[[VAL_2:.*]] = arith.constant false
|
||||
! CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : i8
|
||||
! CHECK-DAG: %[[VAL_4:.*]] = arith.constant 3 : index
|
||||
! CHECK-DAG: %[[VAL_5:.*]] = arith.constant 4 : index
|
||||
! CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
|
||||
! CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_8:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_10:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<3x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
|
||||
! CHECK: cf.br ^bb1(%[[VAL_6]], %[[VAL_4]] : index, index)
|
||||
! CHECK: ^bb1(%[[VAL_13:.*]]: index, %[[VAL_14:.*]]: index):
|
||||
! CHECK: %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_14]], %[[VAL_6]] : index
|
||||
! CHECK: cf.cond_br %[[VAL_15]], ^bb2, ^bb6
|
||||
! CHECK: ^bb2:
|
||||
! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_13]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_16]] typeparams %[[VAL_10]]#1 : (!fir.ref<!fir.array<3x!fir.char<1,?>>>, !fir.shape<1>, index, index) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_18:.*]] = fir.array_coor %[[VAL_9]](%[[VAL_12]]) %[[VAL_16]] : (!fir.ref<!fir.array<3x!fir.char<1,4>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,4>>
|
||||
! CHECK: %[[VAL_19:.*]] = arith.cmpi slt, %[[VAL_5]], %[[VAL_10]]#1 : index
|
||||
! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_5]], %[[VAL_10]]#1 : index
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (index) -> i64
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_17]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_22]], %[[VAL_23]], %[[VAL_21]], %[[VAL_2]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_24:.*]] = fir.undefined !fir.char<1>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[VAL_3]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
|
||||
! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_5]], %[[VAL_20]] : index
|
||||
! CHECK: cf.br ^bb3(%[[VAL_20]], %[[VAL_26]] : index, index)
|
||||
! CHECK: ^bb3(%[[VAL_27:.*]]: index, %[[VAL_28:.*]]: index):
|
||||
! CHECK: %[[VAL_29:.*]] = arith.cmpi sgt, %[[VAL_28]], %[[VAL_6]] : index
|
||||
! CHECK: cf.cond_br %[[VAL_29]], ^bb4, ^bb5
|
||||
! CHECK: ^bb4:
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,4>>) -> !fir.ref<!fir.array<4x!fir.char<1>>>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_30]], %[[VAL_27]] : (!fir.ref<!fir.array<4x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
|
||||
! CHECK: fir.store %[[VAL_25]] to %[[VAL_31]] : !fir.ref<!fir.char<1>>
|
||||
! CHECK: %[[VAL_32:.*]] = arith.addi %[[VAL_27]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_28]], %[[VAL_7]] : index
|
||||
! CHECK: cf.br ^bb3(%[[VAL_32]], %[[VAL_33]] : index, index)
|
||||
! CHECK: ^bb5:
|
||||
|
||||
character(4) :: c1(3)
|
||||
character(*) :: c2(3)
|
||||
c1 = c2
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QQmain() {
|
||||
program p
|
||||
! CHECK-DAG: %[[VAL_0:.*]] = arith.constant 4 : index
|
||||
! CHECK-DAG: %[[VAL_1:.*]] = arith.constant 3 : index
|
||||
! CHECK-DAG: %[[VAL_2:.*]] = arith.constant -1 : i32
|
||||
! CHECK: %[[VAL_5:.*]] = fir.address_of(@_QFEc1) : !fir.ref<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.address_of(@_QFEc2) : !fir.ref<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_2]], %[[VAL_8]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.embox %[[VAL_6]](%[[VAL_10]]) : (!fir.ref<!fir.array<3x!fir.char<1,4>>>, !fir.shape<1>) -> !fir.box<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (!fir.box<!fir.array<3x!fir.char<1,4>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_9]], %[[VAL_12]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: %[[VAL_14:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_9]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<!fir.array<3x!fir.char<1,4>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.emboxchar %[[VAL_15]], %[[VAL_0]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_6]] : (!fir.ref<!fir.array<3x!fir.char<1,4>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_18:.*]] = fir.emboxchar %[[VAL_17]], %[[VAL_0]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPissue(%[[VAL_16]], %[[VAL_18]]) : (!fir.boxchar<1>, !fir.boxchar<1>) -> ()
|
||||
! CHECK: %[[VAL_19:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_2]], %[[VAL_8]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.embox %[[VAL_5]](%[[VAL_10]]) : (!fir.ref<!fir.array<3x!fir.char<1,4>>>, !fir.shape<1>) -> !fir.box<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (!fir.box<!fir.array<3x!fir.char<1,4>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_19]], %[[VAL_21]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: %[[VAL_23:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_19]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: fir.call @_QPcharlit() : () -> ()
|
||||
character(4) :: c1(3)
|
||||
character(4) :: c2(3) = ["abcd", " ", " "]
|
||||
print *, c2
|
||||
call issue(c1, c2)
|
||||
print *, c1
|
||||
call charlit
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end program p
|
||||
character(4) :: c1(3)
|
||||
character(*) :: c2(3)
|
||||
c1 = c2
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcharlit() {
|
||||
! CHECK-LABEL: func @_QQmain() {
|
||||
program p
|
||||
! CHECK-DAG: %[[VAL_0:.*]] = arith.constant 4 : index
|
||||
! CHECK-DAG: %[[VAL_1:.*]] = arith.constant 3 : index
|
||||
! CHECK-DAG: %[[VAL_2:.*]] = arith.constant -1 : i32
|
||||
! CHECK: %[[VAL_5:.*]] = fir.address_of(@_QFEc1) : !fir.ref<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.address_of(@_QFEc2) : !fir.ref<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_2]], %[[VAL_8]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.embox %[[VAL_6]](%[[VAL_10]]) : (!fir.ref<!fir.array<3x!fir.char<1,4>>>, !fir.shape<1>) -> !fir.box<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (!fir.box<!fir.array<3x!fir.char<1,4>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_9]], %[[VAL_12]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: %[[VAL_14:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_9]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<!fir.array<3x!fir.char<1,4>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.emboxchar %[[VAL_15]], %[[VAL_0]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_6]] : (!fir.ref<!fir.array<3x!fir.char<1,4>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_18:.*]] = fir.emboxchar %[[VAL_17]], %[[VAL_0]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPissue(%[[VAL_16]], %[[VAL_18]]) : (!fir.boxchar<1>, !fir.boxchar<1>) -> ()
|
||||
! CHECK: %[[VAL_19:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_2]], %[[VAL_8]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.embox %[[VAL_5]](%[[VAL_10]]) : (!fir.ref<!fir.array<3x!fir.char<1,4>>>, !fir.shape<1>) -> !fir.box<!fir.array<3x!fir.char<1,4>>>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (!fir.box<!fir.array<3x!fir.char<1,4>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_19]], %[[VAL_21]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: %[[VAL_23:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_19]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: fir.call @_QPcharlit() : () -> ()
|
||||
character(4) :: c1(3)
|
||||
character(4) :: c2(3) = ["abcd", " ", " "]
|
||||
print *, c2
|
||||
call issue(c1, c2)
|
||||
print *, c1
|
||||
call charlit
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end program p
|
||||
|
||||
! CHECK-LABEL: func @_QPcharlit() {
|
||||
subroutine charlit
|
||||
! CHECK-DAG: %[[VAL_0:.*]] = arith.constant -1 : i32
|
||||
! CHECK-DAG: %[[VAL_3:.*]] = arith.constant 3 : index
|
||||
! CHECK-DAG: %[[VAL_4:.*]] = arith.constant false
|
||||
! CHECK-DAG: %[[VAL_5:.*]] = arith.constant 4 : index
|
||||
! CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
|
||||
! CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_8:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.address_of(@_QQro.4x3xc1.1636b396a657de68ffb870a885ac44b4) : !fir.ref<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
|
||||
! CHECK: cf.br ^bb1(%[[VAL_6]], %[[VAL_5]] : index, index)
|
||||
! CHECK: ^bb1(%[[VAL_14:.*]]: index, %[[VAL_15:.*]]: index):
|
||||
! CHECK: %[[VAL_16:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[VAL_6]] : index
|
||||
! CHECK: cond_br %[[VAL_16]], ^bb2, ^bb3
|
||||
! CHECK: ^bb2:
|
||||
! CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_14]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_17]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.array_coor %[[VAL_13]](%[[VAL_12]]) %[[VAL_17]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_19]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_21]], %[[VAL_22]], %[[VAL_20]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_15]], %[[VAL_7]] : index
|
||||
! CHECK: cf.br ^bb1(%[[VAL_17]], %[[VAL_23]] : index, index)
|
||||
! CHECK: ^bb3:
|
||||
! CHECK: %[[VAL_24:.*]] = fir.embox %[[VAL_13]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_10]], %[[VAL_25]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: fir.freemem %[[VAL_13]]
|
||||
! CHECK: %[[VAL_27:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_10]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: %[[VAL_28:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_29:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
|
||||
! CHECK: br ^bb4(%[[VAL_6]], %[[VAL_5]] : index, index)
|
||||
! CHECK: ^bb4(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index):
|
||||
! CHECK: %[[VAL_32:.*]] = arith.cmpi sgt, %[[VAL_31]], %[[VAL_6]] : index
|
||||
! CHECK: cond_br %[[VAL_32]], ^bb5, ^bb6
|
||||
! CHECK: ^bb5:
|
||||
! CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_30]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_34:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_33]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_35:.*]] = fir.array_coor %[[VAL_29]](%[[VAL_12]]) %[[VAL_33]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
|
||||
! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_35]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_37]], %[[VAL_38]], %[[VAL_36]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_39:.*]] = arith.subi %[[VAL_31]], %[[VAL_7]] : index
|
||||
! CHECK: br ^bb4(%[[VAL_33]], %[[VAL_39]] : index, index)
|
||||
! CHECK: ^bb6:
|
||||
! CHECK: %[[VAL_40:.*]] = fir.embox %[[VAL_29]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_42:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_28]], %[[VAL_41]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: fir.freemem %[[VAL_29]]
|
||||
! CHECK: %[[VAL_43:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_28]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: %[[VAL_44:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_45:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
|
||||
! CHECK: br ^bb7(%[[VAL_6]], %[[VAL_5]] : index, index)
|
||||
! CHECK: ^bb7(%[[VAL_46:.*]]: index, %[[VAL_47:.*]]: index):
|
||||
! CHECK: %[[VAL_48:.*]] = arith.cmpi sgt, %[[VAL_47]], %[[VAL_6]] : index
|
||||
! CHECK: cond_br %[[VAL_48]], ^bb8, ^bb9
|
||||
! CHECK: ^bb8:
|
||||
! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_46]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_50:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_49]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_51:.*]] = fir.array_coor %[[VAL_45]](%[[VAL_12]]) %[[VAL_49]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
|
||||
! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_51]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_50]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_53]], %[[VAL_54]], %[[VAL_52]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_47]], %[[VAL_7]] : index
|
||||
! CHECK: br ^bb7(%[[VAL_49]], %[[VAL_55]] : index, index)
|
||||
! CHECK: ^bb9:
|
||||
! CHECK: %[[VAL_56:.*]] = fir.embox %[[VAL_45]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_57:.*]] = fir.convert %[[VAL_56]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_58:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_44]], %[[VAL_57]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: fir.freemem %[[VAL_45]]
|
||||
! CHECK: %[[VAL_59:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_44]]) : (!fir.ref<i8>) -> i32
|
||||
print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
|
||||
print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
|
||||
print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end
|
||||
! CHECK-DAG: %[[VAL_0:.*]] = arith.constant -1 : i32
|
||||
! CHECK-DAG: %[[VAL_3:.*]] = arith.constant 3 : index
|
||||
! CHECK-DAG: %[[VAL_4:.*]] = arith.constant false
|
||||
! CHECK-DAG: %[[VAL_5:.*]] = arith.constant 4 : index
|
||||
! CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
|
||||
! CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_8:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.address_of(@_QQro.4x3xc1.1636b396a657de68ffb870a885ac44b4) : !fir.ref<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
|
||||
! CHECK: cf.br ^bb1(%[[VAL_6]], %[[VAL_5]] : index, index)
|
||||
! CHECK: ^bb1(%[[VAL_14:.*]]: index, %[[VAL_15:.*]]: index):
|
||||
! CHECK: %[[VAL_16:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[VAL_6]] : index
|
||||
! CHECK: cond_br %[[VAL_16]], ^bb2, ^bb3
|
||||
! CHECK: ^bb2:
|
||||
! CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_14]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_17]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.array_coor %[[VAL_13]](%[[VAL_12]]) %[[VAL_17]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_19]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_21]], %[[VAL_22]], %[[VAL_20]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_15]], %[[VAL_7]] : index
|
||||
! CHECK: cf.br ^bb1(%[[VAL_17]], %[[VAL_23]] : index, index)
|
||||
! CHECK: ^bb3:
|
||||
! CHECK: %[[VAL_24:.*]] = fir.embox %[[VAL_13]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_10]], %[[VAL_25]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: fir.freemem %[[VAL_13]]
|
||||
! CHECK: %[[VAL_27:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_10]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: %[[VAL_28:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_29:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
|
||||
! CHECK: br ^bb4(%[[VAL_6]], %[[VAL_5]] : index, index)
|
||||
! CHECK: ^bb4(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index):
|
||||
! CHECK: %[[VAL_32:.*]] = arith.cmpi sgt, %[[VAL_31]], %[[VAL_6]] : index
|
||||
! CHECK: cond_br %[[VAL_32]], ^bb5, ^bb6
|
||||
! CHECK: ^bb5:
|
||||
! CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_30]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_34:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_33]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_35:.*]] = fir.array_coor %[[VAL_29]](%[[VAL_12]]) %[[VAL_33]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
|
||||
! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_35]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_37]], %[[VAL_38]], %[[VAL_36]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_39:.*]] = arith.subi %[[VAL_31]], %[[VAL_7]] : index
|
||||
! CHECK: br ^bb4(%[[VAL_33]], %[[VAL_39]] : index, index)
|
||||
! CHECK: ^bb6:
|
||||
! CHECK: %[[VAL_40:.*]] = fir.embox %[[VAL_29]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_42:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_28]], %[[VAL_41]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: fir.freemem %[[VAL_29]]
|
||||
! CHECK: %[[VAL_43:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_28]]) : (!fir.ref<i8>) -> i32
|
||||
! CHECK: %[[VAL_44:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_45:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
|
||||
! CHECK: br ^bb7(%[[VAL_6]], %[[VAL_5]] : index, index)
|
||||
! CHECK: ^bb7(%[[VAL_46:.*]]: index, %[[VAL_47:.*]]: index):
|
||||
! CHECK: %[[VAL_48:.*]] = arith.cmpi sgt, %[[VAL_47]], %[[VAL_6]] : index
|
||||
! CHECK: cond_br %[[VAL_48]], ^bb8, ^bb9
|
||||
! CHECK: ^bb8:
|
||||
! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_46]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_50:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_49]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_51:.*]] = fir.array_coor %[[VAL_45]](%[[VAL_12]]) %[[VAL_49]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
|
||||
! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
|
||||
! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_51]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_50]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_53]], %[[VAL_54]], %[[VAL_52]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_47]], %[[VAL_7]] : index
|
||||
! CHECK: br ^bb7(%[[VAL_49]], %[[VAL_55]] : index, index)
|
||||
! CHECK: ^bb9:
|
||||
! CHECK: %[[VAL_56:.*]] = fir.embox %[[VAL_45]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
|
||||
! CHECK: %[[VAL_57:.*]] = fir.convert %[[VAL_56]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_58:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_44]], %[[VAL_57]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
! CHECK: fir.freemem %[[VAL_45]]
|
||||
! CHECK: %[[VAL_59:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_44]]) : (!fir.ref<i8>) -> i32
|
||||
print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
|
||||
print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
|
||||
print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end
|
||||
|
|
|
|||
|
|
@ -1,46 +1,46 @@
|
|||
! RUN: bbc -o - %s | FileCheck %s
|
||||
|
||||
module units
|
||||
integer, parameter :: preconnected_unit(3) = [0, 5, 6]
|
||||
contains
|
||||
! CHECK-LABEL: _QMunitsPis_preconnected_unit
|
||||
logical function is_preconnected_unit(u)
|
||||
! CHECK: [[units_ssa:%[0-9]+]] = fir.address_of(@_QMunitsECpreconnected_unit) : !fir.ref<!fir.array<3xi32>>
|
||||
integer :: u
|
||||
integer :: i
|
||||
is_preconnected_unit = .true.
|
||||
!do i = lbound(preconnected_unit,1), ubound(preconnected_unit,1)
|
||||
! CHECK: fir.coordinate_of [[units_ssa]]
|
||||
if (preconnected_unit(i) == u) return
|
||||
!end do
|
||||
is_preconnected_unit = .false.
|
||||
end function
|
||||
end module units
|
||||
|
||||
! CHECK-LABEL: _QPcheck_units
|
||||
subroutine check_units
|
||||
use units
|
||||
!do i=-1,8
|
||||
if (is_preconnected_unit(i)) print*, i
|
||||
!enddo
|
||||
end
|
||||
|
||||
! CHECK-LABEL: _QPzero
|
||||
subroutine zero
|
||||
complex, parameter :: a(0) = [(((k,k=1,10),j=-2,2,-1),i=2,-2,-2)]
|
||||
complex, parameter :: b(0) = [(7,i=3,-3)]
|
||||
! CHECK: fir.address_of(@_QQro.0xz4.null) : !fir.ref<!fir.array<0x!fir.complex<4>>>
|
||||
! CHECK-NOT: _QQro
|
||||
print*, '>', a, '<'
|
||||
print*, '>', b, '<'
|
||||
end
|
||||
|
||||
! CHECK-LABEL: _QQmain
|
||||
program prog
|
||||
call check_units
|
||||
call zero
|
||||
end
|
||||
|
||||
! CHECK: fir.global internal @_QFzeroECa constant : !fir.array<0x!fir.complex<4>>
|
||||
! CHECK: %0 = fir.undefined !fir.array<0x!fir.complex<4>>
|
||||
! CHECK: fir.has_value %0 : !fir.array<0x!fir.complex<4>>
|
||||
integer, parameter :: preconnected_unit(3) = [0, 5, 6]
|
||||
contains
|
||||
! CHECK-LABEL: _QMunitsPis_preconnected_unit
|
||||
logical function is_preconnected_unit(u)
|
||||
! CHECK: [[units_ssa:%[0-9]+]] = fir.address_of(@_QMunitsECpreconnected_unit) : !fir.ref<!fir.array<3xi32>>
|
||||
integer :: u
|
||||
integer :: i
|
||||
is_preconnected_unit = .true.
|
||||
!do i = lbound(preconnected_unit,1), ubound(preconnected_unit,1)
|
||||
! CHECK: fir.coordinate_of [[units_ssa]]
|
||||
if (preconnected_unit(i) == u) return
|
||||
!end do
|
||||
is_preconnected_unit = .false.
|
||||
end function
|
||||
end module units
|
||||
|
||||
! CHECK-LABEL: _QPcheck_units
|
||||
subroutine check_units
|
||||
use units
|
||||
!do i=-1,8
|
||||
if (is_preconnected_unit(i)) print*, i
|
||||
!enddo
|
||||
end
|
||||
|
||||
! CHECK-LABEL: _QPzero
|
||||
subroutine zero
|
||||
complex, parameter :: a(0) = [(((k,k=1,10),j=-2,2,-1),i=2,-2,-2)]
|
||||
complex, parameter :: b(0) = [(7,i=3,-3)]
|
||||
! CHECK: fir.address_of(@_QQro.0xz4.null) : !fir.ref<!fir.array<0x!fir.complex<4>>>
|
||||
! CHECK-NOT: _QQro
|
||||
print*, '>', a, '<'
|
||||
print*, '>', b, '<'
|
||||
end
|
||||
|
||||
! CHECK-LABEL: _QQmain
|
||||
program prog
|
||||
call check_units
|
||||
call zero
|
||||
end
|
||||
|
||||
! CHECK: fir.global internal @_QFzeroECa constant : !fir.array<0x!fir.complex<4>>
|
||||
! CHECK: %0 = fir.undefined !fir.array<0x!fir.complex<4>>
|
||||
! CHECK: fir.has_value %0 : !fir.array<0x!fir.complex<4>>
|
||||
|
|
|
|||
|
|
@ -3,175 +3,175 @@
|
|||
! Constant array ctor.
|
||||
! CHECK-LABEL: func @_QPtest1(
|
||||
subroutine test1(a, b)
|
||||
real :: a(3)
|
||||
integer :: b(4)
|
||||
integer, parameter :: constant_array(4) = [6, 7, 42, 9]
|
||||
|
||||
! Array ctors for constant arrays should be outlined as constant globals.
|
||||
|
||||
! Look at inline constructor case
|
||||
! CHECK: %{{.*}} = fir.address_of(@_QQro.3xr4.6e55f044605a4991f15fd4505d83faf4) : !fir.ref<!fir.array<3xf32>>
|
||||
a = (/ 1.0, 2.0, 3.0 /)
|
||||
|
||||
! Look at PARAMETER case
|
||||
! CHECK: %{{.*}} = fir.address_of(@_QQro.4xi4.6a6af0eea868c84da59807d34f7e1a86) : !fir.ref<!fir.array<4xi32>>
|
||||
b = constant_array
|
||||
end subroutine test1
|
||||
|
||||
! Dynamic array ctor with constant extent.
|
||||
! CHECK-LABEL: func @_QPtest2(
|
||||
! CHECK-SAME: %[[a:[^:]*]]: !fir.ref<!fir.array<5xf32>>{{.*}}, %[[b:[^:]*]]: !fir.ref<f32>{{.*}})
|
||||
subroutine test2(a, b)
|
||||
real :: a(5), b
|
||||
real, external :: f
|
||||
|
||||
! Look for the 5 store patterns
|
||||
! CHECK: %[[tmp:.*]] = fir.allocmem !fir.array<5xf32>
|
||||
! CHECK: %[[val:.*]] = fir.call @_QPf(%[[b]]) : (!fir.ref<f32>) -> f32
|
||||
! CHECK: %[[loc:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<5xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK: fir.store %[[val]] to %[[loc]] : !fir.ref<f32>
|
||||
! CHECK: fir.call @_QPf(%{{.*}}) : (!fir.ref<f32>) -> f32
|
||||
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<5xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK: fir.store
|
||||
! CHECK: fir.call @_QPf(
|
||||
! CHECK: fir.coordinate_of %
|
||||
! CHECK: fir.store
|
||||
! CHECK: fir.call @_QPf(
|
||||
! CHECK: fir.coordinate_of %
|
||||
! CHECK: fir.store
|
||||
! CHECK: fir.call @_QPf(
|
||||
! CHECK: fir.coordinate_of %
|
||||
! CHECK: fir.store
|
||||
|
||||
! After the ctor done, loop to copy result to `a`
|
||||
! CHECK-DAG: fir.array_coor %[[tmp:.*]](%
|
||||
! CHECK-DAG: %[[ai:.*]] = fir.array_coor %[[a]](%
|
||||
! CHECK: fir.store %{{.*}} to %[[ai]] : !fir.ref<f32>
|
||||
! CHECK: fir.freemem %[[tmp]]
|
||||
|
||||
a = [f(b), f(b+1), f(b+2), f(b+5), f(b+11)]
|
||||
end subroutine test2
|
||||
|
||||
! Dynamic array ctor with dynamic extent.
|
||||
! CHECK-LABEL: func @_QPtest3(
|
||||
! CHECK-SAME: %[[a:.*]]: !fir.box<!fir.array<?xf32>>{{.*}})
|
||||
subroutine test3(a)
|
||||
real :: a(:)
|
||||
real, allocatable :: b(:), c(:)
|
||||
interface
|
||||
subroutine test3b(x)
|
||||
real, allocatable :: x(:)
|
||||
end subroutine test3b
|
||||
end interface
|
||||
interface
|
||||
function test3c
|
||||
real, allocatable :: test3c(:)
|
||||
end function test3c
|
||||
end interface
|
||||
|
||||
! CHECK: fir.call @_QPtest3b
|
||||
! CHECK: %{{.*}}:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %{{.*}} = fir.box_addr %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: %[[tmp:.*]] = fir.allocmem f32, %c32
|
||||
call test3b(b)
|
||||
! CHECK: %[[hp1:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}} {uniq_name = ".array.expr"}
|
||||
! CHECK-DAG: %[[rep:.*]] = fir.convert %{{.*}} : (!fir.heap<f32>) -> !fir.ref<i8>
|
||||
! CHECK-DAG: %[[res:.*]] = fir.convert %{{.*}} : (index) -> i64
|
||||
! CHECK: %{{.*}} = fir.call @realloc(%[[rep]], %[[res]]) : (!fir.ref<i8>, i64) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: fir.call @_QPtest3c
|
||||
! CHECK: fir.save_result
|
||||
! CHECK: %[[tmp2:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}}#1 {uniq_name = ".array.expr"}
|
||||
! CHECK: fir.call @realloc
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%
|
||||
! CHECK: fir.array_coor %[[tmp:.*]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK-NEXT: fir.load
|
||||
! CHECK-NEXT: fir.array_coor %arg0 %{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK-NEXT: fir.store
|
||||
! CHECK: fir.freemem %[[tmp]]
|
||||
! CHECK: fir.freemem %[[tmp2]]
|
||||
! CHECK: %[[alli:.*]] = fir.box_addr %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.freemem %[[alli]]
|
||||
! CHECK: fir.freemem %[[hp1]]
|
||||
a = (/ b, test3c() /)
|
||||
end subroutine test3
|
||||
|
||||
! CHECK-LABEL: func @_QPtest4(
|
||||
subroutine test4(a, b, n1, m1)
|
||||
real :: a(:)
|
||||
real :: b(:,:)
|
||||
integer, external :: f1, f2, f3
|
||||
|
||||
! Dynamic array ctor with dynamic extent using implied do loops.
|
||||
! CHECK-DAG: fir.alloca index {bindc_name = ".buff.pos"}
|
||||
! CHECK-DAG: fir.alloca index {bindc_name = ".buff.size"}
|
||||
! CHECK-DAG: %[[c32:.*]] = arith.constant 32 : index
|
||||
! CHECK: fir.allocmem f32, %[[c32]]
|
||||
! CHECK: fir.call @_QPf1(%{{.*}}) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: fir.call @_QPf2(%arg2) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: fir.call @_QPf3(%{{.*}}) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: %[[q:.*]] = fir.coordinate_of %arg1, %{{.*}}, %{{.*}} : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
|
||||
! CHECK: %[[q2:.*]] = fir.load %[[q]] : !fir.ref<f32>
|
||||
! CHECK: fir.store %[[q2]] to %{{.*}} : !fir.ref<f32>
|
||||
! CHECK: fir.freemem %{{.*}}
|
||||
! CHECK-NEXT: return
|
||||
a = [ ((b(i,j), j=f1(i),f2(n1),f3(m1+i)), i=1,n1,m1) ]
|
||||
end subroutine test4
|
||||
|
||||
! CHECK-LABEL: func @_QPtest5(
|
||||
! CHECK-SAME: %[[a:[^:]*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[array2:[^:]*]]: !fir.ref<!fir.array<2xf32>>{{.*}})
|
||||
subroutine test5(a, array2)
|
||||
real :: a(:)
|
||||
real, parameter :: const_array1(2) = [ 1.0, 2.0 ]
|
||||
real :: array2(2)
|
||||
|
||||
! Array ctor with runtime element values and constant extents.
|
||||
! Concatenation of array values of constant extent.
|
||||
! CHECK: %[[res:.*]] = fir.allocmem !fir.array<4xf32>
|
||||
! CHECK: fir.address_of(@_QQro.2xr4.057a7f5ab69cb695657046b18832c330) : !fir.ref<!fir.array<2xf32>>
|
||||
! CHECK: %[[tmp1:.*]] = fir.allocmem !fir.array<2xf32>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[tmp2:.*]] = fir.allocmem !fir.array<2xf32>
|
||||
! CHECK: = fir.array_coor %[[array2]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<2xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK: = fir.array_coor %[[tmp2]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<2xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: = fir.array_coor %{{.*}}(%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<4xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK: = fir.array_coor %[[a]] %{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK-DAG: fir.freemem %{{.*}}
|
||||
! CHECK-DAG: fir.freemem %[[tmp2]]
|
||||
! CHECK-DAG: fir.freemem %[[tmp1]]
|
||||
! CHECK: return
|
||||
a = [ const_array1, array2 ]
|
||||
end subroutine test5
|
||||
|
||||
! CHECK-LABEL: func @_QPtest6(
|
||||
subroutine test6(c, d, e)
|
||||
character(5) :: c(3)
|
||||
character(5) :: d, e
|
||||
! CHECK: = fir.allocmem !fir.array<2x!fir.char<1,5>>
|
||||
! CHECK: fir.call @realloc
|
||||
! CHECK: %[[t:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<2x!fir.char<1,5>>>, index) -> !fir.ref<!fir.char<1,5>>
|
||||
! CHECK: %[[to:.*]] = fir.convert %[[t]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%[[to]], %{{.*}}, %{{.*}}, %false) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: fir.call @realloc
|
||||
! CHECK: %[[t:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<2x!fir.char<1,5>>>, index) -> !fir.ref<!fir.char<1,5>>
|
||||
! CHECK: %[[to:.*]] = fir.convert %[[t]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%[[to]], %{{.*}}, %{{.*}}, %false) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: fir.freemem %{{.*}}
|
||||
c = (/ d, e /)
|
||||
end subroutine test6
|
||||
|
||||
! CHECK-LABEL: func @_QPtest7(
|
||||
! CHECK: %[[i:.*]] = fir.convert %{{.*}} : (index) -> i8
|
||||
! CHECK: %[[und:.*]] = fir.undefined !fir.char<1>
|
||||
! CHECK: %[[scalar:.*]] = fir.insert_value %[[und]], %[[i]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
|
||||
! CHECK: ^bb{{[0-9]+}}(%{{.*}}: !fir.heap<!fir.char<1>>): // 2 preds
|
||||
! CHECK: fir.store %[[scalar]] to %{{.*}} : !fir.ref<!fir.char<1>>
|
||||
subroutine test7(a, n)
|
||||
character(1) :: a(n)
|
||||
a = (/ (CHAR(i), i=1,n) /)
|
||||
end subroutine test7
|
||||
|
||||
! CHECK: fir.global internal @_QQro.3xr4.{{.*}}(dense<[1.000000e+00, 2.000000e+00, 3.000000e+00]> : tensor<3xf32>) constant : !fir.array<3xf32>
|
||||
|
||||
! CHECK: fir.global internal @_QQro.4xi4.{{.*}}(dense<[6, 7, 42, 9]> : tensor<4xi32>) constant : !fir.array<4xi32>
|
||||
real :: a(3)
|
||||
integer :: b(4)
|
||||
integer, parameter :: constant_array(4) = [6, 7, 42, 9]
|
||||
|
||||
! Array ctors for constant arrays should be outlined as constant globals.
|
||||
|
||||
! Look at inline constructor case
|
||||
! CHECK: %{{.*}} = fir.address_of(@_QQro.3xr4.6e55f044605a4991f15fd4505d83faf4) : !fir.ref<!fir.array<3xf32>>
|
||||
a = (/ 1.0, 2.0, 3.0 /)
|
||||
|
||||
! Look at PARAMETER case
|
||||
! CHECK: %{{.*}} = fir.address_of(@_QQro.4xi4.6a6af0eea868c84da59807d34f7e1a86) : !fir.ref<!fir.array<4xi32>>
|
||||
b = constant_array
|
||||
end subroutine test1
|
||||
|
||||
! Dynamic array ctor with constant extent.
|
||||
! CHECK-LABEL: func @_QPtest2(
|
||||
! CHECK-SAME: %[[a:[^:]*]]: !fir.ref<!fir.array<5xf32>>{{.*}}, %[[b:[^:]*]]: !fir.ref<f32>{{.*}})
|
||||
subroutine test2(a, b)
|
||||
real :: a(5), b
|
||||
real, external :: f
|
||||
|
||||
! Look for the 5 store patterns
|
||||
! CHECK: %[[tmp:.*]] = fir.allocmem !fir.array<5xf32>
|
||||
! CHECK: %[[val:.*]] = fir.call @_QPf(%[[b]]) : (!fir.ref<f32>) -> f32
|
||||
! CHECK: %[[loc:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<5xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK: fir.store %[[val]] to %[[loc]] : !fir.ref<f32>
|
||||
! CHECK: fir.call @_QPf(%{{.*}}) : (!fir.ref<f32>) -> f32
|
||||
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<5xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK: fir.store
|
||||
! CHECK: fir.call @_QPf(
|
||||
! CHECK: fir.coordinate_of %
|
||||
! CHECK: fir.store
|
||||
! CHECK: fir.call @_QPf(
|
||||
! CHECK: fir.coordinate_of %
|
||||
! CHECK: fir.store
|
||||
! CHECK: fir.call @_QPf(
|
||||
! CHECK: fir.coordinate_of %
|
||||
! CHECK: fir.store
|
||||
|
||||
! After the ctor done, loop to copy result to `a`
|
||||
! CHECK-DAG: fir.array_coor %[[tmp:.*]](%
|
||||
! CHECK-DAG: %[[ai:.*]] = fir.array_coor %[[a]](%
|
||||
! CHECK: fir.store %{{.*}} to %[[ai]] : !fir.ref<f32>
|
||||
! CHECK: fir.freemem %[[tmp]]
|
||||
|
||||
a = [f(b), f(b+1), f(b+2), f(b+5), f(b+11)]
|
||||
end subroutine test2
|
||||
|
||||
! Dynamic array ctor with dynamic extent.
|
||||
! CHECK-LABEL: func @_QPtest3(
|
||||
! CHECK-SAME: %[[a:.*]]: !fir.box<!fir.array<?xf32>>{{.*}})
|
||||
subroutine test3(a)
|
||||
real :: a(:)
|
||||
real, allocatable :: b(:), c(:)
|
||||
interface
|
||||
subroutine test3b(x)
|
||||
real, allocatable :: x(:)
|
||||
end subroutine test3b
|
||||
end interface
|
||||
interface
|
||||
function test3c
|
||||
real, allocatable :: test3c(:)
|
||||
end function test3c
|
||||
end interface
|
||||
|
||||
! CHECK: fir.call @_QPtest3b
|
||||
! CHECK: %{{.*}}:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %{{.*}} = fir.box_addr %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: %[[tmp:.*]] = fir.allocmem f32, %c32
|
||||
call test3b(b)
|
||||
! CHECK: %[[hp1:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}} {uniq_name = ".array.expr"}
|
||||
! CHECK-DAG: %[[rep:.*]] = fir.convert %{{.*}} : (!fir.heap<f32>) -> !fir.ref<i8>
|
||||
! CHECK-DAG: %[[res:.*]] = fir.convert %{{.*}} : (index) -> i64
|
||||
! CHECK: %{{.*}} = fir.call @realloc(%[[rep]], %[[res]]) : (!fir.ref<i8>, i64) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: fir.call @_QPtest3c
|
||||
! CHECK: fir.save_result
|
||||
! CHECK: %[[tmp2:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}}#1 {uniq_name = ".array.expr"}
|
||||
! CHECK: fir.call @realloc
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%
|
||||
! CHECK: fir.array_coor %[[tmp:.*]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK-NEXT: fir.load
|
||||
! CHECK-NEXT: fir.array_coor %arg0 %{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK-NEXT: fir.store
|
||||
! CHECK: fir.freemem %[[tmp]]
|
||||
! CHECK: fir.freemem %[[tmp2]]
|
||||
! CHECK: %[[alli:.*]] = fir.box_addr %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.freemem %[[alli]]
|
||||
! CHECK: fir.freemem %[[hp1]]
|
||||
a = (/ b, test3c() /)
|
||||
end subroutine test3
|
||||
|
||||
! CHECK-LABEL: func @_QPtest4(
|
||||
subroutine test4(a, b, n1, m1)
|
||||
real :: a(:)
|
||||
real :: b(:,:)
|
||||
integer, external :: f1, f2, f3
|
||||
|
||||
! Dynamic array ctor with dynamic extent using implied do loops.
|
||||
! CHECK-DAG: fir.alloca index {bindc_name = ".buff.pos"}
|
||||
! CHECK-DAG: fir.alloca index {bindc_name = ".buff.size"}
|
||||
! CHECK-DAG: %[[c32:.*]] = arith.constant 32 : index
|
||||
! CHECK: fir.allocmem f32, %[[c32]]
|
||||
! CHECK: fir.call @_QPf1(%{{.*}}) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: fir.call @_QPf2(%arg2) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: fir.call @_QPf3(%{{.*}}) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: %[[q:.*]] = fir.coordinate_of %arg1, %{{.*}}, %{{.*}} : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
|
||||
! CHECK: %[[q2:.*]] = fir.load %[[q]] : !fir.ref<f32>
|
||||
! CHECK: fir.store %[[q2]] to %{{.*}} : !fir.ref<f32>
|
||||
! CHECK: fir.freemem %{{.*}}
|
||||
! CHECK-NEXT: return
|
||||
a = [ ((b(i,j), j=f1(i),f2(n1),f3(m1+i)), i=1,n1,m1) ]
|
||||
end subroutine test4
|
||||
|
||||
! CHECK-LABEL: func @_QPtest5(
|
||||
! CHECK-SAME: %[[a:[^:]*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[array2:[^:]*]]: !fir.ref<!fir.array<2xf32>>{{.*}})
|
||||
subroutine test5(a, array2)
|
||||
real :: a(:)
|
||||
real, parameter :: const_array1(2) = [ 1.0, 2.0 ]
|
||||
real :: array2(2)
|
||||
|
||||
! Array ctor with runtime element values and constant extents.
|
||||
! Concatenation of array values of constant extent.
|
||||
! CHECK: %[[res:.*]] = fir.allocmem !fir.array<4xf32>
|
||||
! CHECK: fir.address_of(@_QQro.2xr4.057a7f5ab69cb695657046b18832c330) : !fir.ref<!fir.array<2xf32>>
|
||||
! CHECK: %[[tmp1:.*]] = fir.allocmem !fir.array<2xf32>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[tmp2:.*]] = fir.allocmem !fir.array<2xf32>
|
||||
! CHECK: = fir.array_coor %[[array2]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<2xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK: = fir.array_coor %[[tmp2]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<2xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: = fir.array_coor %{{.*}}(%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<4xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
|
||||
! CHECK: = fir.array_coor %[[a]] %{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK-DAG: fir.freemem %{{.*}}
|
||||
! CHECK-DAG: fir.freemem %[[tmp2]]
|
||||
! CHECK-DAG: fir.freemem %[[tmp1]]
|
||||
! CHECK: return
|
||||
a = [ const_array1, array2 ]
|
||||
end subroutine test5
|
||||
|
||||
! CHECK-LABEL: func @_QPtest6(
|
||||
subroutine test6(c, d, e)
|
||||
character(5) :: c(3)
|
||||
character(5) :: d, e
|
||||
! CHECK: = fir.allocmem !fir.array<2x!fir.char<1,5>>
|
||||
! CHECK: fir.call @realloc
|
||||
! CHECK: %[[t:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<2x!fir.char<1,5>>>, index) -> !fir.ref<!fir.char<1,5>>
|
||||
! CHECK: %[[to:.*]] = fir.convert %[[t]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%[[to]], %{{.*}}, %{{.*}}, %false) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: fir.call @realloc
|
||||
! CHECK: %[[t:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<2x!fir.char<1,5>>>, index) -> !fir.ref<!fir.char<1,5>>
|
||||
! CHECK: %[[to:.*]] = fir.convert %[[t]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memcpy.p0i8.p0i8.i64(%[[to]], %{{.*}}, %{{.*}}, %false) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: fir.freemem %{{.*}}
|
||||
c = (/ d, e /)
|
||||
end subroutine test6
|
||||
|
||||
! CHECK-LABEL: func @_QPtest7(
|
||||
! CHECK: %[[i:.*]] = fir.convert %{{.*}} : (index) -> i8
|
||||
! CHECK: %[[und:.*]] = fir.undefined !fir.char<1>
|
||||
! CHECK: %[[scalar:.*]] = fir.insert_value %[[und]], %[[i]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
|
||||
! CHECK: ^bb{{[0-9]+}}(%{{.*}}: !fir.heap<!fir.char<1>>): // 2 preds
|
||||
! CHECK: fir.store %[[scalar]] to %{{.*}} : !fir.ref<!fir.char<1>>
|
||||
subroutine test7(a, n)
|
||||
character(1) :: a(n)
|
||||
a = (/ (CHAR(i), i=1,n) /)
|
||||
end subroutine test7
|
||||
|
||||
! CHECK: fir.global internal @_QQro.3xr4.{{.*}}(dense<[1.000000e+00, 2.000000e+00, 3.000000e+00]> : tensor<3xf32>) constant : !fir.array<3xf32>
|
||||
|
||||
! CHECK: fir.global internal @_QQro.4xi4.{{.*}}(dense<[6, 7, 42, 9]> : tensor<4xi32>) constant : !fir.array<4xi32>
|
||||
|
|
|
|||
|
|
@ -6,197 +6,196 @@
|
|||
! (for the operation)
|
||||
|
||||
module test_ops
|
||||
interface
|
||||
integer elemental function elem_func(i)
|
||||
integer, intent(in) :: i
|
||||
end function
|
||||
integer elemental function elem_func_logical(l)
|
||||
logical(8), intent(in) :: l
|
||||
end function
|
||||
integer elemental function elem_func_logical4(l)
|
||||
logical, intent(in) :: l
|
||||
end function
|
||||
integer elemental function elem_func_real(x)
|
||||
real(8), value :: x
|
||||
end function
|
||||
end interface
|
||||
integer :: i(10), j(10), iscalar
|
||||
logical(8) :: a(10), b(10)
|
||||
real(8) :: x(10), y(10)
|
||||
complex(8) :: z1(10), z2
|
||||
|
||||
contains
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_binary_ops() {
|
||||
subroutine check_binary_ops()
|
||||
print *, elem_func(i+j)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_27:.*]] = arith.addi %[[VAL_25]], %[[VAL_26]] : i32
|
||||
! CHECK: fir.store %[[VAL_27]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_binary_ops_2() {
|
||||
subroutine check_binary_ops_2()
|
||||
print *, elem_func(i*iscalar)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: %[[VAL_13:.*]] = fir.load %{{.*}} : !fir.ref<i32>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_27:.*]] = arith.muli %[[VAL_25]], %[[VAL_13]] : i32
|
||||
! CHECK: fir.store %[[VAL_27]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_negate() {
|
||||
subroutine check_negate()
|
||||
print *, elem_func(-i)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_22:.*]] = arith.constant 0 : i32
|
||||
! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_22]], %[[VAL_21]] : i32
|
||||
! CHECK: fir.store %[[VAL_23]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_convert() {
|
||||
subroutine check_convert()
|
||||
print *, elem_func(int(x))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (f64) -> i32
|
||||
! CHECK: fir.store %[[VAL_22]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_exteremum() {
|
||||
subroutine check_exteremum()
|
||||
print *, elem_func(min(i, j))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_27:.*]] = arith.cmpi slt, %[[VAL_25]], %[[VAL_26]] : i32
|
||||
! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_25]], %[[VAL_26]] : i32
|
||||
! CHECK: fir.store %[[VAL_28]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_logical_unary_ops() {
|
||||
subroutine check_logical_unary_ops()
|
||||
print *, elem_func_logical(.not.b)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<8>
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant true
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_22:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (!fir.logical<8>) -> i1
|
||||
! CHECK: %[[VAL_24:.*]] = arith.xori %[[VAL_23]], %[[VAL_12]] : i1
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (i1) -> !fir.logical<8>
|
||||
! CHECK: fir.store %[[VAL_25]] to %[[VAL_0]] : !fir.ref<!fir.logical<8>>
|
||||
! CHECK: fir.call @_QPelem_func_logical(%[[VAL_0]]) : (!fir.ref<!fir.logical<8>>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_logical_binary_ops() {
|
||||
subroutine check_logical_binary_ops()
|
||||
print *, elem_func_logical(a.eqv.b)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<8>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_25]] : (!fir.logical<8>) -> i1
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_26]] : (!fir.logical<8>) -> i1
|
||||
! CHECK: %[[VAL_29:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_28]] : i1
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i1) -> !fir.logical<8>
|
||||
! CHECK: fir.store %[[VAL_30]] to %[[VAL_0]] : !fir.ref<!fir.logical<8>>
|
||||
! CHECK: fir.call @_QPelem_func_logical(%[[VAL_0]]) : (!fir.ref<!fir.logical<8>>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_compare() {
|
||||
subroutine check_compare()
|
||||
print *, elem_func_logical4(x.lt.y)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<4>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_27:.*]] = arith.cmpf olt, %[[VAL_25]], %[[VAL_26]] : f64
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i1) -> !fir.logical<4>
|
||||
! CHECK: fir.store %[[VAL_28]] to %[[VAL_0]] : !fir.ref<!fir.logical<4>>
|
||||
! CHECK: fir.call @_QPelem_func_logical4(%[[VAL_0]]) : (!fir.ref<!fir.logical<4>>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_pow() {
|
||||
subroutine check_pow()
|
||||
print *, elem_func_real(x**y)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca f64
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_27:.*]] = fir.call @__fd_pow_1(%[[VAL_25]], %[[VAL_26]]) : (f64, f64) -> f64
|
||||
! CHECK: fir.store %[[VAL_27]] to %[[VAL_0]] : !fir.ref<f64>
|
||||
! CHECK: %[[VAL_28:.*]] = fir.call @_QPelem_func_real(%[[VAL_0]]) : (!fir.ref<f64>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_cmplx_part() {
|
||||
subroutine check_cmplx_part()
|
||||
print *, elem_func_real(AIMAG(z1 + z2))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca f64
|
||||
! CHECK: %[[VAL_13:.*]] = fir.load %{{.*}} : !fir.ref<!fir.complex<8>>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_23:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.complex<8>>, index) -> !fir.complex<8>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.addc %[[VAL_23]], %[[VAL_13]] : !fir.complex<8>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.extract_value %[[VAL_24]], [1 : index] : (!fir.complex<8>) -> f64
|
||||
! CHECK: fir.store %[[VAL_25]] to %[[VAL_0]] : !fir.ref<f64>
|
||||
! CHECK: fir.call @_QPelem_func_real(%[[VAL_0]]) : (!fir.ref<f64>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_parentheses() {
|
||||
subroutine check_parentheses()
|
||||
print *, elem_func_real((x))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca f64
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : f64
|
||||
! CHECK: fir.store %[[VAL_22]] to %[[VAL_0]] : !fir.ref<f64>
|
||||
! CHECK: fir.call @_QPelem_func_real(%[[VAL_0]]) : (!fir.ref<f64>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_parentheses_logical() {
|
||||
subroutine check_parentheses_logical()
|
||||
print *, elem_func_logical((a))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<8>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : !fir.logical<8>
|
||||
! CHECK: fir.store %[[VAL_22]] to %[[VAL_0]] : !fir.ref<!fir.logical<8>>
|
||||
! CHECK: fir.call @_QPelem_func_logical(%[[VAL_0]]) : (!fir.ref<!fir.logical<8>>) -> i32
|
||||
end subroutine
|
||||
|
||||
subroutine check_parentheses_derived(a)
|
||||
type t
|
||||
integer :: i
|
||||
end type
|
||||
interface
|
||||
integer elemental function elem_func_derived(x)
|
||||
import :: t
|
||||
type(t), intent(in) :: x
|
||||
end function
|
||||
end interface
|
||||
type(t), pointer :: a(:)
|
||||
print *, elem_func_derived((a))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_access %{{.}}, %{{.*}}
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : !fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>
|
||||
! CHECK: %[[FIELD:.*]] = fir.field_index i, !fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>
|
||||
! CHECK: %[[FROM:.*]] = fir.coordinate_of %[[VAL_22]], %[[FIELD]] : (!fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[TO:.*]] = fir.coordinate_of %[[VAL_0]], %[[FIELD]] : (!fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL:.*]] = fir.load %[[FROM]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL]] to %[[TO]] : !fir.ref<i32>
|
||||
! CHECK: %25 = fir.call @_QPelem_func_derived(%[[VAL_0]]) : (!fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>) -> i32
|
||||
end subroutine
|
||||
end module
|
||||
|
||||
interface
|
||||
integer elemental function elem_func(i)
|
||||
integer, intent(in) :: i
|
||||
end function
|
||||
integer elemental function elem_func_logical(l)
|
||||
logical(8), intent(in) :: l
|
||||
end function
|
||||
integer elemental function elem_func_logical4(l)
|
||||
logical, intent(in) :: l
|
||||
end function
|
||||
integer elemental function elem_func_real(x)
|
||||
real(8), value :: x
|
||||
end function
|
||||
end interface
|
||||
integer :: i(10), j(10), iscalar
|
||||
logical(8) :: a(10), b(10)
|
||||
real(8) :: x(10), y(10)
|
||||
complex(8) :: z1(10), z2
|
||||
|
||||
contains
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_binary_ops() {
|
||||
subroutine check_binary_ops()
|
||||
print *, elem_func(i+j)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_27:.*]] = arith.addi %[[VAL_25]], %[[VAL_26]] : i32
|
||||
! CHECK: fir.store %[[VAL_27]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_binary_ops_2() {
|
||||
subroutine check_binary_ops_2()
|
||||
print *, elem_func(i*iscalar)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: %[[VAL_13:.*]] = fir.load %{{.*}} : !fir.ref<i32>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_27:.*]] = arith.muli %[[VAL_25]], %[[VAL_13]] : i32
|
||||
! CHECK: fir.store %[[VAL_27]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_negate() {
|
||||
subroutine check_negate()
|
||||
print *, elem_func(-i)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_22:.*]] = arith.constant 0 : i32
|
||||
! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_22]], %[[VAL_21]] : i32
|
||||
! CHECK: fir.store %[[VAL_23]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_convert() {
|
||||
subroutine check_convert()
|
||||
print *, elem_func(int(x))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (f64) -> i32
|
||||
! CHECK: fir.store %[[VAL_22]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_exteremum() {
|
||||
subroutine check_exteremum()
|
||||
print *, elem_func(min(i, j))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca i32
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_27:.*]] = arith.cmpi slt, %[[VAL_25]], %[[VAL_26]] : i32
|
||||
! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_25]], %[[VAL_26]] : i32
|
||||
! CHECK: fir.store %[[VAL_28]] to %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPelem_func(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_logical_unary_ops() {
|
||||
subroutine check_logical_unary_ops()
|
||||
print *, elem_func_logical(.not.b)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<8>
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant true
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_22:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (!fir.logical<8>) -> i1
|
||||
! CHECK: %[[VAL_24:.*]] = arith.xori %[[VAL_23]], %[[VAL_12]] : i1
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (i1) -> !fir.logical<8>
|
||||
! CHECK: fir.store %[[VAL_25]] to %[[VAL_0]] : !fir.ref<!fir.logical<8>>
|
||||
! CHECK: fir.call @_QPelem_func_logical(%[[VAL_0]]) : (!fir.ref<!fir.logical<8>>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_logical_binary_ops() {
|
||||
subroutine check_logical_binary_ops()
|
||||
print *, elem_func_logical(a.eqv.b)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<8>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_25]] : (!fir.logical<8>) -> i1
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_26]] : (!fir.logical<8>) -> i1
|
||||
! CHECK: %[[VAL_29:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_28]] : i1
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i1) -> !fir.logical<8>
|
||||
! CHECK: fir.store %[[VAL_30]] to %[[VAL_0]] : !fir.ref<!fir.logical<8>>
|
||||
! CHECK: fir.call @_QPelem_func_logical(%[[VAL_0]]) : (!fir.ref<!fir.logical<8>>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_compare() {
|
||||
subroutine check_compare()
|
||||
print *, elem_func_logical4(x.lt.y)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<4>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_27:.*]] = arith.cmpf olt, %[[VAL_25]], %[[VAL_26]] : f64
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i1) -> !fir.logical<4>
|
||||
! CHECK: fir.store %[[VAL_28]] to %[[VAL_0]] : !fir.ref<!fir.logical<4>>
|
||||
! CHECK: fir.call @_QPelem_func_logical4(%[[VAL_0]]) : (!fir.ref<!fir.logical<4>>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_pow() {
|
||||
subroutine check_pow()
|
||||
print *, elem_func_real(x**y)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca f64
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_25:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_26:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_27:.*]] = fir.call @__fd_pow_1(%[[VAL_25]], %[[VAL_26]]) : (f64, f64) -> f64
|
||||
! CHECK: fir.store %[[VAL_27]] to %[[VAL_0]] : !fir.ref<f64>
|
||||
! CHECK: %[[VAL_28:.*]] = fir.call @_QPelem_func_real(%[[VAL_0]]) : (!fir.ref<f64>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_cmplx_part() {
|
||||
subroutine check_cmplx_part()
|
||||
print *, elem_func_real(AIMAG(z1 + z2))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca f64
|
||||
! CHECK: %[[VAL_13:.*]] = fir.load %{{.*}} : !fir.ref<!fir.complex<8>>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_23:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.complex<8>>, index) -> !fir.complex<8>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.addc %[[VAL_23]], %[[VAL_13]] : !fir.complex<8>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.extract_value %[[VAL_24]], [1 : index] : (!fir.complex<8>) -> f64
|
||||
! CHECK: fir.store %[[VAL_25]] to %[[VAL_0]] : !fir.ref<f64>
|
||||
! CHECK: fir.call @_QPelem_func_real(%[[VAL_0]]) : (!fir.ref<f64>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_parentheses() {
|
||||
subroutine check_parentheses()
|
||||
print *, elem_func_real((x))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca f64
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10xf64>, index) -> f64
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : f64
|
||||
! CHECK: fir.store %[[VAL_22]] to %[[VAL_0]] : !fir.ref<f64>
|
||||
! CHECK: fir.call @_QPelem_func_real(%[[VAL_0]]) : (!fir.ref<f64>) -> i32
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest_opsPcheck_parentheses_logical() {
|
||||
subroutine check_parentheses_logical()
|
||||
print *, elem_func_logical((a))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.logical<8>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<10x!fir.logical<8>>, index) -> !fir.logical<8>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : !fir.logical<8>
|
||||
! CHECK: fir.store %[[VAL_22]] to %[[VAL_0]] : !fir.ref<!fir.logical<8>>
|
||||
! CHECK: fir.call @_QPelem_func_logical(%[[VAL_0]]) : (!fir.ref<!fir.logical<8>>) -> i32
|
||||
end subroutine
|
||||
|
||||
subroutine check_parentheses_derived(a)
|
||||
type t
|
||||
integer :: i
|
||||
end type
|
||||
interface
|
||||
integer elemental function elem_func_derived(x)
|
||||
import :: t
|
||||
type(t), intent(in) :: x
|
||||
end function
|
||||
end interface
|
||||
type(t), pointer :: a(:)
|
||||
print *, elem_func_derived((a))
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_access %{{.}}, %{{.*}}
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : !fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>
|
||||
! CHECK: %[[FIELD:.*]] = fir.field_index i, !fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>
|
||||
! CHECK: %[[FROM:.*]] = fir.coordinate_of %[[VAL_22]], %[[FIELD]] : (!fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[TO:.*]] = fir.coordinate_of %[[VAL_0]], %[[FIELD]] : (!fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL:.*]] = fir.load %[[FROM]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL]] to %[[TO]] : !fir.ref<i32>
|
||||
! CHECK: %25 = fir.call @_QPelem_func_derived(%[[VAL_0]]) : (!fir.ref<!fir.type<_QMtest_opsFcheck_parentheses_derivedTt{i:i32}>>) -> i32
|
||||
end subroutine
|
||||
end module
|
||||
|
|
|
|||
|
|
@ -3,104 +3,104 @@
|
|||
|
||||
module scalar_in_elem
|
||||
|
||||
contains
|
||||
elemental integer function elem_by_ref(a,b) result(r)
|
||||
integer, intent(in) :: a
|
||||
real, intent(in) :: b
|
||||
r = a + b
|
||||
contains
|
||||
elemental integer function elem_by_ref(a,b) result(r)
|
||||
integer, intent(in) :: a
|
||||
real, intent(in) :: b
|
||||
r = a + b
|
||||
end function
|
||||
elemental integer function elem_by_valueref(a,b) result(r)
|
||||
integer, value :: a
|
||||
real, value :: b
|
||||
r = a + b
|
||||
end function
|
||||
|
||||
! CHECK-LABEL: func @_QMscalar_in_elemPtest_elem_by_ref(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) {
|
||||
subroutine test_elem_by_ref(i, j)
|
||||
integer :: i(100), j(100)
|
||||
! CHECK: %[[tmp:.*]] = fir.alloca f32
|
||||
! CHECK: %[[cst:.*]] = arith.constant 4.200000e+01 : f32
|
||||
! CHECK: fir.store %[[cst]] to %[[tmp]] : !fir.ref<f32>
|
||||
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[j:.*]] = fir.array_coor %[[arg1]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
|
||||
! CHECK: fir.call @_QMscalar_in_elemPelem_by_ref(%[[j]], %[[tmp]]) : (!fir.ref<i32>, !fir.ref<f32>) -> i32
|
||||
! CHECK: fir.result
|
||||
i = elem_by_ref(j, 42.)
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QMscalar_in_elemPtest_elem_by_valueref(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) {
|
||||
subroutine test_elem_by_valueref(i, j)
|
||||
integer :: i(100), j(100)
|
||||
! CHECK-DAG: %[[tmpA:.*]] = fir.alloca i32 {adapt.valuebyref}
|
||||
! CHECK-DAG: %[[tmpB:.*]] = fir.alloca f32 {adapt.valuebyref}
|
||||
! CHECK: %[[jload:.*]] = fir.array_load %[[arg1]]
|
||||
! CHECK: %[[cst:.*]] = arith.constant 4.200000e+01 : f32
|
||||
! CHECK: fir.store %[[cst]] to %[[tmpB]] : !fir.ref<f32>
|
||||
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[j:.*]] = fir.array_fetch %[[jload]], %{{.*}} : (!fir.array<100xi32>, index) -> i32
|
||||
! CHECK: fir.store %[[j]] to %[[tmpA]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QMscalar_in_elemPelem_by_valueref(%[[tmpA]], %[[tmpB]]) : (!fir.ref<i32>, !fir.ref<f32>) -> i32
|
||||
! CHECK: fir.result
|
||||
i = elem_by_valueref(j, 42.)
|
||||
end
|
||||
end module
|
||||
|
||||
|
||||
! Test that impure elemental functions cause ordered loops to be emitted
|
||||
subroutine test_loop_order(i, j)
|
||||
integer :: i(:), j(:)
|
||||
interface
|
||||
elemental integer function pure_func(j)
|
||||
integer, intent(in) :: j
|
||||
end function
|
||||
elemental integer function elem_by_valueref(a,b) result(r)
|
||||
integer, value :: a
|
||||
real, value :: b
|
||||
r = a + b
|
||||
elemental impure integer function impure_func(j)
|
||||
integer, intent(in) :: j
|
||||
end function
|
||||
|
||||
! CHECK-LABEL: func @_QMscalar_in_elemPtest_elem_by_ref(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) {
|
||||
subroutine test_elem_by_ref(i, j)
|
||||
integer :: i(100), j(100)
|
||||
! CHECK: %[[tmp:.*]] = fir.alloca f32
|
||||
! CHECK: %[[cst:.*]] = arith.constant 4.200000e+01 : f32
|
||||
! CHECK: fir.store %[[cst]] to %[[tmp]] : !fir.ref<f32>
|
||||
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[j:.*]] = fir.array_coor %[[arg1]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
|
||||
! CHECK: fir.call @_QMscalar_in_elemPelem_by_ref(%[[j]], %[[tmp]]) : (!fir.ref<i32>, !fir.ref<f32>) -> i32
|
||||
! CHECK: fir.result
|
||||
i = elem_by_ref(j, 42.)
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QMscalar_in_elemPtest_elem_by_valueref(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) {
|
||||
subroutine test_elem_by_valueref(i, j)
|
||||
integer :: i(100), j(100)
|
||||
! CHECK-DAG: %[[tmpA:.*]] = fir.alloca i32 {adapt.valuebyref}
|
||||
! CHECK-DAG: %[[tmpB:.*]] = fir.alloca f32 {adapt.valuebyref}
|
||||
! CHECK: %[[jload:.*]] = fir.array_load %[[arg1]]
|
||||
! CHECK: %[[cst:.*]] = arith.constant 4.200000e+01 : f32
|
||||
! CHECK: fir.store %[[cst]] to %[[tmpB]] : !fir.ref<f32>
|
||||
|
||||
! CHECK: fir.do_loop
|
||||
! CHECK: %[[j:.*]] = fir.array_fetch %[[jload]], %{{.*}} : (!fir.array<100xi32>, index) -> i32
|
||||
! CHECK: fir.store %[[j]] to %[[tmpA]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QMscalar_in_elemPelem_by_valueref(%[[tmpA]], %[[tmpB]]) : (!fir.ref<i32>, !fir.ref<f32>) -> i32
|
||||
! CHECK: fir.result
|
||||
i = elem_by_valueref(j, 42.)
|
||||
end
|
||||
end module
|
||||
|
||||
|
||||
! Test that impure elemental functions cause ordered loops to be emitted
|
||||
subroutine test_loop_order(i, j)
|
||||
integer :: i(:), j(:)
|
||||
interface
|
||||
elemental integer function pure_func(j)
|
||||
integer, intent(in) :: j
|
||||
end function
|
||||
elemental impure integer function impure_func(j)
|
||||
integer, intent(in) :: j
|
||||
end function
|
||||
end interface
|
||||
|
||||
i = 42 + pure_func(j)
|
||||
i = 42 + impure_func(j)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_loop_order(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_2]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_4:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 42 : i32
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_8:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_6]] : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.do_loop %[[VAL_10:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_6]] unordered iter_args(%[[VAL_11:.*]] = %[[VAL_4]]) -> (!fir.array<?xi32>) {
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.array_coor %[[VAL_1]] %[[VAL_13]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.call @_QPpure_func(%[[VAL_14]]) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_5]], %[[VAL_15]] : i32
|
||||
! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_11]], %[[VAL_16]], %[[VAL_10]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
|
||||
! CHECK: fir.result %[[VAL_17]] : !fir.array<?xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_4]], %[[VAL_18:.*]] to %[[VAL_0]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_19]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
|
||||
! CHECK: %[[VAL_22:.*]] = arith.constant 42 : i32
|
||||
! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_20]]#1, %[[VAL_23]] : index
|
||||
! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] iter_args(%[[VAL_28:.*]] = %[[VAL_21]]) -> (!fir.array<?xi32>) {
|
||||
! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_27]], %[[VAL_29]] : index
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_coor %[[VAL_1]] %[[VAL_30]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_32:.*]] = fir.call @_QPimpure_func(%[[VAL_31]]) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_22]], %[[VAL_32]] : i32
|
||||
! CHECK: %[[VAL_34:.*]] = fir.array_update %[[VAL_28]], %[[VAL_33]], %[[VAL_27]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
|
||||
! CHECK: fir.result %[[VAL_34]] : !fir.array<?xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_21]], %[[VAL_35:.*]] to %[[VAL_0]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end interface
|
||||
|
||||
i = 42 + pure_func(j)
|
||||
i = 42 + impure_func(j)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_loop_order(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_2]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_4:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 42 : i32
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_8:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_6]] : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.do_loop %[[VAL_10:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_6]] unordered iter_args(%[[VAL_11:.*]] = %[[VAL_4]]) -> (!fir.array<?xi32>) {
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.array_coor %[[VAL_1]] %[[VAL_13]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.call @_QPpure_func(%[[VAL_14]]) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_5]], %[[VAL_15]] : i32
|
||||
! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_11]], %[[VAL_16]], %[[VAL_10]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
|
||||
! CHECK: fir.result %[[VAL_17]] : !fir.array<?xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_4]], %[[VAL_18:.*]] to %[[VAL_0]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_19]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
|
||||
! CHECK: %[[VAL_22:.*]] = arith.constant 42 : i32
|
||||
! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_20]]#1, %[[VAL_23]] : index
|
||||
! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] iter_args(%[[VAL_28:.*]] = %[[VAL_21]]) -> (!fir.array<?xi32>) {
|
||||
! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_27]], %[[VAL_29]] : index
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_coor %[[VAL_1]] %[[VAL_30]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_32:.*]] = fir.call @_QPimpure_func(%[[VAL_31]]) : (!fir.ref<i32>) -> i32
|
||||
! CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_22]], %[[VAL_32]] : i32
|
||||
! CHECK: %[[VAL_34:.*]] = fir.array_update %[[VAL_28]], %[[VAL_33]], %[[VAL_27]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
|
||||
! CHECK: fir.result %[[VAL_34]] : !fir.array<?xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_21]], %[[VAL_35:.*]] to %[[VAL_0]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -2,92 +2,92 @@
|
|||
|
||||
! CHECK-LABEL: func @_QQmain
|
||||
program p
|
||||
! CHECK-DAG: [[I:%[0-9]+]] = fir.alloca i32 {{{.*}}uniq_name = "_QFEi"}
|
||||
! CHECK-DAG: [[N:%[0-9]+]] = fir.alloca i32 {{{.*}}uniq_name = "_QFEn"}
|
||||
! CHECK: [[T:%[0-9]+]] = fir.address_of(@_QFEt) : !fir.ref<!fir.array<3xi32>>
|
||||
integer :: n, foo, t(3)
|
||||
! CHECK: [[N]]
|
||||
! CHECK-COUNT-3: fir.coordinate_of [[T]]
|
||||
n = 100; t(1) = 111; t(2) = 222; t(3) = 333
|
||||
! CHECK-DAG: [[I:%[0-9]+]] = fir.alloca i32 {{{.*}}uniq_name = "_QFEi"}
|
||||
! CHECK-DAG: [[N:%[0-9]+]] = fir.alloca i32 {{{.*}}uniq_name = "_QFEn"}
|
||||
! CHECK: [[T:%[0-9]+]] = fir.address_of(@_QFEt) : !fir.ref<!fir.array<3xi32>>
|
||||
integer :: n, foo, t(3)
|
||||
! CHECK: [[N]]
|
||||
! CHECK-COUNT-3: fir.coordinate_of [[T]]
|
||||
n = 100; t(1) = 111; t(2) = 222; t(3) = 333
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: addi {{.*}} %c5
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[B:%[0-9]+]]
|
||||
! CHECK: [[C:%[0-9]+]] = fir.coordinate_of [[T]]
|
||||
! CHECK: fir.call @_QPfoo
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[D:%[0-9]+]]
|
||||
associate (a => n, b => n+5, c => t(2), d => foo(7))
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: addi {{.*}} %c5
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[B:%[0-9]+]]
|
||||
! CHECK: [[C:%[0-9]+]] = fir.coordinate_of [[T]]
|
||||
! CHECK: fir.call @_QPfoo
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[D:%[0-9]+]]
|
||||
associate (a => n, b => n+5, c => t(2), d => foo(7))
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: addi %{{[0-9]*}}, %c1
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[N]]
|
||||
a = a + 1
|
||||
! CHECK: fir.load [[C]]
|
||||
! CHECK: addi %{{[0-9]*}}, %c1
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[C]]
|
||||
c = c + 1
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: addi %{{[0-9]*}}, %c1
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[N]]
|
||||
n = n + 1
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: fir.embox [[T]]
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: fir.load [[B]]
|
||||
! CHECK: fir.load [[C]]
|
||||
! CHECK: fir.load [[D]]
|
||||
print*, n, t, a, b, c, d ! expect: 102 111 223 333 102 105 223 7
|
||||
! CHECK: addi %{{[0-9]*}}, %c1
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[N]]
|
||||
a = a + 1
|
||||
! CHECK: fir.load [[C]]
|
||||
! CHECK: addi %{{[0-9]*}}, %c1
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[C]]
|
||||
c = c + 1
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: addi %{{[0-9]*}}, %c1
|
||||
! CHECK: fir.store %{{[0-9]*}} to [[N]]
|
||||
n = n + 1
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: fir.embox [[T]]
|
||||
! CHECK: fir.load [[N]]
|
||||
! CHECK: fir.load [[B]]
|
||||
! CHECK: fir.load [[C]]
|
||||
! CHECK: fir.load [[D]]
|
||||
print*, n, t, a, b, c, d ! expect: 102 111 223 333 102 105 223 7
|
||||
end associate
|
||||
|
||||
call nest
|
||||
|
||||
associate (x=>i)
|
||||
! CHECK: [[IVAL:%[0-9]+]] = fir.load [[I]] : !fir.ref<i32>
|
||||
! CHECK: [[TWO:%.*]] = arith.constant 2 : i32
|
||||
! CHECK: arith.cmpi eq, [[IVAL]], [[TWO]] : i32
|
||||
! CHECK: ^bb
|
||||
if (x==2) goto 9
|
||||
! CHECK: [[IVAL:%[0-9]+]] = fir.load [[I]] : !fir.ref<i32>
|
||||
! CHECK: [[THREE:%.*]] = arith.constant 3 : i32
|
||||
! CHECK: arith.cmpi eq, [[IVAL]], [[THREE]] : i32
|
||||
! CHECK: ^bb
|
||||
! CHECK: fir.call @_FortranAStopStatementText
|
||||
! CHECK: fir.unreachable
|
||||
! CHECK: ^bb
|
||||
if (x==3) stop 'Halt'
|
||||
! CHECK: fir.call @_FortranAioOutputAscii
|
||||
print*, "ok"
|
||||
9 end associate
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo
|
||||
integer function foo(x)
|
||||
integer x
|
||||
integer, save :: i = 0
|
||||
i = i + x
|
||||
foo = i
|
||||
end function foo
|
||||
|
||||
! CHECK-LABEL: func @_QPnest(
|
||||
subroutine nest
|
||||
integer, parameter :: n = 10
|
||||
integer :: a(5), b(n)
|
||||
associate (s => sequence(size(a)))
|
||||
a = s
|
||||
associate(t => sequence(n))
|
||||
b = t
|
||||
! CHECK: cond_br %{{.*}}, [[BB1:\^bb[0-9]]], [[BB2:\^bb[0-9]]]
|
||||
! CHECK: [[BB1]]:
|
||||
! CHECK: br [[BB3:\^bb[0-9]]]
|
||||
! CHECK: [[BB2]]:
|
||||
if (a(1) > b(1)) goto 9
|
||||
end associate
|
||||
|
||||
call nest
|
||||
|
||||
associate (x=>i)
|
||||
! CHECK: [[IVAL:%[0-9]+]] = fir.load [[I]] : !fir.ref<i32>
|
||||
! CHECK: [[TWO:%.*]] = arith.constant 2 : i32
|
||||
! CHECK: arith.cmpi eq, [[IVAL]], [[TWO]] : i32
|
||||
! CHECK: ^bb
|
||||
if (x==2) goto 9
|
||||
! CHECK: [[IVAL:%[0-9]+]] = fir.load [[I]] : !fir.ref<i32>
|
||||
! CHECK: [[THREE:%.*]] = arith.constant 3 : i32
|
||||
! CHECK: arith.cmpi eq, [[IVAL]], [[THREE]] : i32
|
||||
! CHECK: ^bb
|
||||
! CHECK: fir.call @_FortranAStopStatementText
|
||||
! CHECK: fir.unreachable
|
||||
! CHECK: ^bb
|
||||
if (x==3) stop 'Halt'
|
||||
! CHECK: fir.call @_FortranAioOutputAscii
|
||||
print*, "ok"
|
||||
9 end associate
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo
|
||||
integer function foo(x)
|
||||
integer x
|
||||
integer, save :: i = 0
|
||||
i = i + x
|
||||
foo = i
|
||||
end function foo
|
||||
|
||||
! CHECK-LABEL: func @_QPnest(
|
||||
subroutine nest
|
||||
integer, parameter :: n = 10
|
||||
integer :: a(5), b(n)
|
||||
associate (s => sequence(size(a)))
|
||||
a = s
|
||||
associate(t => sequence(n))
|
||||
b = t
|
||||
! CHECK: cond_br %{{.*}}, [[BB1:\^bb[0-9]]], [[BB2:\^bb[0-9]]]
|
||||
! CHECK: [[BB1]]:
|
||||
! CHECK: br [[BB3:\^bb[0-9]]]
|
||||
! CHECK: [[BB2]]:
|
||||
if (a(1) > b(1)) goto 9
|
||||
end associate
|
||||
a = a * a
|
||||
end associate
|
||||
! CHECK: br [[BB3]]
|
||||
! CHECK: [[BB3]]:
|
||||
9 print *, sum(a), sum(b) ! expect: 55 55
|
||||
contains
|
||||
function sequence(n)
|
||||
integer sequence(n)
|
||||
sequence = [(i,i=1,n)]
|
||||
end function
|
||||
end subroutine nest
|
||||
a = a * a
|
||||
end associate
|
||||
! CHECK: br [[BB3]]
|
||||
! CHECK: [[BB3]]:
|
||||
9 print *, sum(a), sum(b) ! expect: 55 55
|
||||
contains
|
||||
function sequence(n)
|
||||
integer sequence(n)
|
||||
sequence = [(i,i=1,n)]
|
||||
end function
|
||||
end subroutine nest
|
||||
|
|
|
|||
|
|
@ -9,65 +9,65 @@
|
|||
|
||||
! CHECK-LABEL: _QPs0
|
||||
subroutine s0
|
||||
common // a0, b0
|
||||
|
||||
! CHECK: call void @_QPs(float* bitcast ([8 x i8]* @_QB to float*), float* bitcast (i8* getelementptr inbounds ([8 x i8], [8 x i8]* @_QB, i32 0, i64 4) to float*))
|
||||
call s(a0, b0)
|
||||
end subroutine s0
|
||||
|
||||
! CHECK-LABEL: _QPs1
|
||||
subroutine s1
|
||||
common /x/ a1, b1
|
||||
data a1 /1.0/, b1 /2.0/
|
||||
|
||||
! CHECK: call void @_QPs(float* getelementptr inbounds ({ float, float }, { float, float }* @_QBx, i32 0, i32 0), float* bitcast (i8* getelementptr (i8, i8* bitcast ({ float, float }* @_QBx to i8*), i64 4) to float*))
|
||||
call s(a1, b1)
|
||||
end subroutine s1
|
||||
|
||||
! CHECK-LABEL: _QPs2
|
||||
subroutine s2
|
||||
common /y/ a2, b2, c2
|
||||
|
||||
! CHECK: call void @_QPs(float* bitcast ([12 x i8]* @_QBy to float*), float* bitcast (i8* getelementptr inbounds ([12 x i8], [12 x i8]* @_QBy, i32 0, i64 4) to float*))
|
||||
call s(a2, b2)
|
||||
end subroutine s2
|
||||
|
||||
! Test that common initialized through aliases of common members are getting
|
||||
! the correct initializer.
|
||||
! CHECK-LABEL: _QPs3
|
||||
subroutine s3
|
||||
integer :: i = 42
|
||||
real :: x
|
||||
complex :: c
|
||||
real :: glue(2)
|
||||
real :: y = 3.
|
||||
equivalence (i, x), (glue(1), c), (glue(2), y)
|
||||
! x and c are not directly initialized, but overlapping aliases are.
|
||||
common /z/ x, c
|
||||
end subroutine s3
|
||||
|
||||
module mod_with_common
|
||||
integer :: i, j
|
||||
common /c_in_mod/ i, j
|
||||
end module
|
||||
! CHECK-LABEL: _QPs4
|
||||
subroutine s4
|
||||
use mod_with_common
|
||||
! CHECK: load i32, i32* bitcast ([8 x i8]* @_QBc_in_mod to i32*)
|
||||
print *, i
|
||||
! CHECK: load i32, i32* bitcast (i8* getelementptr inbounds ([8 x i8], [8 x i8]* @_QBc_in_mod, i32 0, i64 4) to i32*)
|
||||
print *, j
|
||||
end subroutine s4
|
||||
|
||||
! CHECK-LABEL: _QPs5
|
||||
subroutine s5
|
||||
real r(1:0)
|
||||
common /rien/ r
|
||||
end subroutine s5
|
||||
|
||||
! CHECK-LABEL: _QPs6
|
||||
subroutine s6
|
||||
real r1(1:0), r2(1:0), x, y
|
||||
common /with_empty_equiv/ x, r1, y
|
||||
equivalence(r1, r2)
|
||||
end subroutine s6
|
||||
common // a0, b0
|
||||
|
||||
! CHECK: call void @_QPs(float* bitcast ([8 x i8]* @_QB to float*), float* bitcast (i8* getelementptr inbounds ([8 x i8], [8 x i8]* @_QB, i32 0, i64 4) to float*))
|
||||
call s(a0, b0)
|
||||
end subroutine s0
|
||||
|
||||
! CHECK-LABEL: _QPs1
|
||||
subroutine s1
|
||||
common /x/ a1, b1
|
||||
data a1 /1.0/, b1 /2.0/
|
||||
|
||||
! CHECK: call void @_QPs(float* getelementptr inbounds ({ float, float }, { float, float }* @_QBx, i32 0, i32 0), float* bitcast (i8* getelementptr (i8, i8* bitcast ({ float, float }* @_QBx to i8*), i64 4) to float*))
|
||||
call s(a1, b1)
|
||||
end subroutine s1
|
||||
|
||||
! CHECK-LABEL: _QPs2
|
||||
subroutine s2
|
||||
common /y/ a2, b2, c2
|
||||
|
||||
! CHECK: call void @_QPs(float* bitcast ([12 x i8]* @_QBy to float*), float* bitcast (i8* getelementptr inbounds ([12 x i8], [12 x i8]* @_QBy, i32 0, i64 4) to float*))
|
||||
call s(a2, b2)
|
||||
end subroutine s2
|
||||
|
||||
! Test that common initialized through aliases of common members are getting
|
||||
! the correct initializer.
|
||||
! CHECK-LABEL: _QPs3
|
||||
subroutine s3
|
||||
integer :: i = 42
|
||||
real :: x
|
||||
complex :: c
|
||||
real :: glue(2)
|
||||
real :: y = 3.
|
||||
equivalence (i, x), (glue(1), c), (glue(2), y)
|
||||
! x and c are not directly initialized, but overlapping aliases are.
|
||||
common /z/ x, c
|
||||
end subroutine s3
|
||||
|
||||
module mod_with_common
|
||||
integer :: i, j
|
||||
common /c_in_mod/ i, j
|
||||
end module
|
||||
! CHECK-LABEL: _QPs4
|
||||
subroutine s4
|
||||
use mod_with_common
|
||||
! CHECK: load i32, i32* bitcast ([8 x i8]* @_QBc_in_mod to i32*)
|
||||
print *, i
|
||||
! CHECK: load i32, i32* bitcast (i8* getelementptr inbounds ([8 x i8], [8 x i8]* @_QBc_in_mod, i32 0, i64 4) to i32*)
|
||||
print *, j
|
||||
end subroutine s4
|
||||
|
||||
! CHECK-LABEL: _QPs5
|
||||
subroutine s5
|
||||
real r(1:0)
|
||||
common /rien/ r
|
||||
end subroutine s5
|
||||
|
||||
! CHECK-LABEL: _QPs6
|
||||
subroutine s6
|
||||
real r1(1:0), r2(1:0), x, y
|
||||
common /with_empty_equiv/ x, r1, y
|
||||
equivalence(r1, r2)
|
||||
end subroutine s6
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -2,55 +2,55 @@
|
|||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
module m
|
||||
type t(k1, k2)
|
||||
integer(4), kind :: k1 = 7
|
||||
integer(8), kind :: k2
|
||||
character(k1) :: c(k2)
|
||||
end type
|
||||
|
||||
type t2(k1, k2)
|
||||
integer(4), kind :: k1
|
||||
integer(8), kind :: k2
|
||||
type(t(k1+3, k2+4)) :: at
|
||||
end type
|
||||
|
||||
type t3(k)
|
||||
integer, kind :: k
|
||||
type(t3(k)), pointer :: at3
|
||||
end type
|
||||
|
||||
type t4(k)
|
||||
integer, kind :: k
|
||||
real(-k) :: i
|
||||
end type
|
||||
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test mangling of derived type with kind parameters
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTtK7K12{c:!fir.array<12x!fir.char<1,?>>
|
||||
subroutine foo(at)
|
||||
type(t(k2=12)) :: at
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo2
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTt2K12K13{at:!fir.type<_QMmTtK15K17{c:!fir.array<17x!fir.char<1,?>>}>}>>
|
||||
subroutine foo2(at2)
|
||||
type(t2(12, 13)) :: at2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo3
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTt3K7{at3:!fir.box<!fir.ptr<!fir.type<_QMmTt3K7>>>}>>
|
||||
subroutine foo3(at3)
|
||||
type(t3(7)) :: at3
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo4
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTt4KN4{i:f32}>>
|
||||
subroutine foo4(at4)
|
||||
type(t4(-4)) :: at4
|
||||
end subroutine
|
||||
end module
|
||||
type t(k1, k2)
|
||||
integer(4), kind :: k1 = 7
|
||||
integer(8), kind :: k2
|
||||
character(k1) :: c(k2)
|
||||
end type
|
||||
|
||||
type t2(k1, k2)
|
||||
integer(4), kind :: k1
|
||||
integer(8), kind :: k2
|
||||
type(t(k1+3, k2+4)) :: at
|
||||
end type
|
||||
|
||||
type t3(k)
|
||||
integer, kind :: k
|
||||
type(t3(k)), pointer :: at3
|
||||
end type
|
||||
|
||||
type t4(k)
|
||||
integer, kind :: k
|
||||
real(-k) :: i
|
||||
end type
|
||||
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test mangling of derived type with kind parameters
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTtK7K12{c:!fir.array<12x!fir.char<1,?>>
|
||||
subroutine foo(at)
|
||||
type(t(k2=12)) :: at
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo2
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTt2K12K13{at:!fir.type<_QMmTtK15K17{c:!fir.array<17x!fir.char<1,?>>}>}>>
|
||||
subroutine foo2(at2)
|
||||
type(t2(12, 13)) :: at2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo3
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTt3K7{at3:!fir.box<!fir.ptr<!fir.type<_QMmTt3K7>>>}>>
|
||||
subroutine foo3(at3)
|
||||
type(t3(7)) :: at3
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMmPfoo4
|
||||
! CHECK-SAME: !fir.ref<!fir.type<_QMmTt4KN4{i:f32}>>
|
||||
subroutine foo4(at4)
|
||||
type(t4(-4)) :: at4
|
||||
end subroutine
|
||||
end module
|
||||
|
|
|
|||
|
|
@ -4,192 +4,192 @@
|
|||
! Note: only testing non parametrized derived type here.
|
||||
|
||||
module d
|
||||
type r
|
||||
real :: x
|
||||
end type
|
||||
type r2
|
||||
real :: x_array(10, 20)
|
||||
end type
|
||||
type c
|
||||
character(10) :: ch
|
||||
end type
|
||||
type c2
|
||||
character(10) :: ch_array(20, 30)
|
||||
end type
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test simple derived type symbol lowering
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMdPderived_dummy(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.type<_QMdTr{x:f32}>>{{.*}}, %{{.*}}: !fir.ref<!fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>>{{.*}}) {
|
||||
subroutine derived_dummy(some_r, some_c2)
|
||||
type(r) :: some_r
|
||||
type(c2) :: some_c2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMdPlocal_derived(
|
||||
subroutine local_derived()
|
||||
! CHECK-DAG: fir.alloca !fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>
|
||||
! CHECK-DAG: fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
type(r) :: some_r
|
||||
type(c2) :: some_c2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMdPsaved_derived(
|
||||
subroutine saved_derived()
|
||||
! CHECK-DAG: fir.address_of(@_QMdFsaved_derivedEsome_c2) : !fir.ref<!fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>>
|
||||
! CHECK-DAG: fir.address_of(@_QMdFsaved_derivedEsome_r) : !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
type(r), save :: some_r
|
||||
type(c2), save :: some_c2
|
||||
call use_symbols(some_r, some_c2)
|
||||
end subroutine
|
||||
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test simple derived type references
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMdPscalar_numeric_ref(
|
||||
subroutine scalar_numeric_ref()
|
||||
! CHECK: %[[alloc:.*]] = fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
type(r) :: some_r
|
||||
! CHECK: %[[field:.*]] = fir.field_index x, !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: fir.coordinate_of %[[alloc]], %[[field]] : (!fir.ref<!fir.type<_QMdTr{x:f32}>>, !fir.field) -> !fir.ref<f32>
|
||||
call real_bar(some_r%x)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMdPscalar_character_ref(
|
||||
subroutine scalar_character_ref()
|
||||
! CHECK: %[[alloc:.*]] = fir.alloca !fir.type<_QMdTc{ch:!fir.char<1,10>}>
|
||||
type(c) :: some_c
|
||||
! CHECK: %[[field:.*]] = fir.field_index ch, !fir.type<_QMdTc{ch:!fir.char<1,10>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[alloc]], %[[field]] : (!fir.ref<!fir.type<_QMdTc{ch:!fir.char<1,10>}>>, !fir.field) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 : index
|
||||
! CHECK-DAG: %[[conv:.*]] = fir.convert %[[coor]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: fir.emboxchar %[[conv]], %c10 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call char_bar(some_c%ch)
|
||||
end subroutine
|
||||
|
||||
! FIXME: coordinate of generated for derived%array_comp(i) are not zero based as they
|
||||
! should be.
|
||||
|
||||
! CHECK-LABEL: func @_QMdParray_comp_elt_ref(
|
||||
subroutine array_comp_elt_ref()
|
||||
type(r2) :: some_r2
|
||||
! CHECK: %[[alloc:.*]] = fir.alloca !fir.type<_QMdTr2{x_array:!fir.array<10x20xf32>}>
|
||||
! CHECK: %[[field:.*]] = fir.field_index x_array, !fir.type<_QMdTr2{x_array:!fir.array<10x20xf32>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[alloc]], %[[field]] : (!fir.ref<!fir.type<_QMdTr2{x_array:!fir.array<10x20xf32>}>>, !fir.field) -> !fir.ref<!fir.array<10x20xf32>>
|
||||
! CHECK-DAG: %[[index1:.*]] = arith.subi %c5{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK-DAG: %[[index2:.*]] = arith.subi %c6{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: fir.coordinate_of %[[coor]], %[[index1]], %[[index2]] : (!fir.ref<!fir.array<10x20xf32>>, i64, i64) -> !fir.ref<f32>
|
||||
call real_bar(some_r2%x_array(5, 6))
|
||||
end subroutine
|
||||
|
||||
|
||||
! CHECK-LABEL: func @_QMdPchar_array_comp_elt_ref(
|
||||
subroutine char_array_comp_elt_ref()
|
||||
type(c2) :: some_c2
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>>, !fir.field) -> !fir.ref<!fir.array<20x30x!fir.char<1,10>>>
|
||||
! CHECK-DAG: %[[index1:.*]] = arith.subi %c5{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK-DAG: %[[index2:.*]] = arith.subi %c6{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: fir.coordinate_of %[[coor]], %[[index1]], %[[index2]] : (!fir.ref<!fir.array<20x30x!fir.char<1,10>>>, i64, i64) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: fir.emboxchar %{{.*}}, %c10 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call char_bar(some_c2%ch_array(5, 6))
|
||||
end subroutine
|
||||
|
||||
! CHECK: @_QMdParray_elt_comp_ref
|
||||
subroutine array_elt_comp_ref()
|
||||
type(r) :: some_r_array(100)
|
||||
! CHECK: %[[alloca:.*]] = fir.alloca !fir.array<100x!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: %[[index:.*]] = arith.subi %c5{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: %[[elt:.*]] = fir.coordinate_of %[[alloca]], %[[index]] : (!fir.ref<!fir.array<100x!fir.type<_QMdTr{x:f32}>>>, i64) -> !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: %[[field:.*]] = fir.field_index x, !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: fir.coordinate_of %[[elt]], %[[field]] : (!fir.ref<!fir.type<_QMdTr{x:f32}>>, !fir.field) -> !fir.ref<f32>
|
||||
call real_bar(some_r_array(5)%x)
|
||||
end subroutine
|
||||
|
||||
! CHECK: @_QMdPchar_array_elt_comp_ref
|
||||
subroutine char_array_elt_comp_ref()
|
||||
type(c) :: some_c_array(100)
|
||||
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<100x!fir.type<_QMdTc{ch:!fir.char<1,10>}>>>, i64) -> !fir.ref<!fir.type<_QMdTc{ch:!fir.char<1,10>}>>
|
||||
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.type<_QMdTc{ch:!fir.char<1,10>}>>, !fir.field) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: fir.emboxchar %{{.*}}, %c10{{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call char_bar(some_c_array(5)%ch)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test loading derived type components
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! Most of the other tests only require lowering code to compute the address of
|
||||
! components. This one requires loading a component which tests other code paths
|
||||
! in lowering.
|
||||
|
||||
! CHECK-LABEL: func @_QMdPscalar_numeric_load(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
real function scalar_numeric_load(some_r)
|
||||
type(r) :: some_r
|
||||
! CHECK: %[[field:.*]] = fir.field_index x, !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[arg0]], %[[field]] : (!fir.ref<!fir.type<_QMdTr{x:f32}>>, !fir.field) -> !fir.ref<f32>
|
||||
! CHECK: fir.load %[[coor]]
|
||||
scalar_numeric_load = some_r%x
|
||||
end function
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test returned derived types (no length parameters)
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMdPbar_return_derived() -> !fir.type<_QMdTr{x:f32}>
|
||||
function bar_return_derived()
|
||||
! CHECK: %[[res:.*]] = fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
type(r) :: bar_return_derived
|
||||
! CHECK: %[[resLoad:.*]] = fir.load %[[res]] : !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: return %[[resLoad]] : !fir.type<_QMdTr{x:f32}>
|
||||
end function
|
||||
|
||||
! CHECK-LABEL: func @_QMdPcall_bar_return_derived(
|
||||
subroutine call_bar_return_derived()
|
||||
! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: %[[call:.*]] = fir.call @_QMdPbar_return_derived() : () -> !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: fir.save_result %[[call]] to %[[tmp]] : !fir.type<_QMdTr{x:f32}>, !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: fir.call @_QPr_bar(%[[tmp]]) : (!fir.ref<!fir.type<_QMdTr{x:f32}>>) -> ()
|
||||
call r_bar(bar_return_derived())
|
||||
end subroutine
|
||||
|
||||
end module
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test derived type with pointer/allocatable components
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
module d2
|
||||
type recursive_t
|
||||
real :: x
|
||||
type(recursive_t), pointer :: ptr
|
||||
end type
|
||||
contains
|
||||
! CHECK-LABEL: func @_QMd2Ptest_recursive_type(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.type<_QMd2Trecursive_t{x:f32,ptr:!fir.box<!fir.ptr<!fir.type<_QMd2Trecursive_t>>>}>>{{.*}}) {
|
||||
subroutine test_recursive_type(some_recursive)
|
||||
type(recursive_t) :: some_recursive
|
||||
end subroutine
|
||||
end module
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test global derived type symbol lowering
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
module data_mod
|
||||
use d
|
||||
type(r) :: some_r
|
||||
type(c2) :: some_c2
|
||||
end module
|
||||
|
||||
! Test globals
|
||||
|
||||
! CHECK-DAG: fir.global @_QMdata_modEsome_c2 : !fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>
|
||||
! CHECK-DAG: fir.global @_QMdata_modEsome_r : !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK-DAG: fir.global internal @_QMdFsaved_derivedEsome_c2 : !fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>
|
||||
! CHECK-DAG: fir.global internal @_QMdFsaved_derivedEsome_r : !fir.type<_QMdTr{x:f32}>
|
||||
type r
|
||||
real :: x
|
||||
end type
|
||||
type r2
|
||||
real :: x_array(10, 20)
|
||||
end type
|
||||
type c
|
||||
character(10) :: ch
|
||||
end type
|
||||
type c2
|
||||
character(10) :: ch_array(20, 30)
|
||||
end type
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test simple derived type symbol lowering
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMdPderived_dummy(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.type<_QMdTr{x:f32}>>{{.*}}, %{{.*}}: !fir.ref<!fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>>{{.*}}) {
|
||||
subroutine derived_dummy(some_r, some_c2)
|
||||
type(r) :: some_r
|
||||
type(c2) :: some_c2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMdPlocal_derived(
|
||||
subroutine local_derived()
|
||||
! CHECK-DAG: fir.alloca !fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>
|
||||
! CHECK-DAG: fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
type(r) :: some_r
|
||||
type(c2) :: some_c2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMdPsaved_derived(
|
||||
subroutine saved_derived()
|
||||
! CHECK-DAG: fir.address_of(@_QMdFsaved_derivedEsome_c2) : !fir.ref<!fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>>
|
||||
! CHECK-DAG: fir.address_of(@_QMdFsaved_derivedEsome_r) : !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
type(r), save :: some_r
|
||||
type(c2), save :: some_c2
|
||||
call use_symbols(some_r, some_c2)
|
||||
end subroutine
|
||||
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test simple derived type references
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMdPscalar_numeric_ref(
|
||||
subroutine scalar_numeric_ref()
|
||||
! CHECK: %[[alloc:.*]] = fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
type(r) :: some_r
|
||||
! CHECK: %[[field:.*]] = fir.field_index x, !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: fir.coordinate_of %[[alloc]], %[[field]] : (!fir.ref<!fir.type<_QMdTr{x:f32}>>, !fir.field) -> !fir.ref<f32>
|
||||
call real_bar(some_r%x)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMdPscalar_character_ref(
|
||||
subroutine scalar_character_ref()
|
||||
! CHECK: %[[alloc:.*]] = fir.alloca !fir.type<_QMdTc{ch:!fir.char<1,10>}>
|
||||
type(c) :: some_c
|
||||
! CHECK: %[[field:.*]] = fir.field_index ch, !fir.type<_QMdTc{ch:!fir.char<1,10>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[alloc]], %[[field]] : (!fir.ref<!fir.type<_QMdTc{ch:!fir.char<1,10>}>>, !fir.field) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 : index
|
||||
! CHECK-DAG: %[[conv:.*]] = fir.convert %[[coor]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: fir.emboxchar %[[conv]], %c10 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call char_bar(some_c%ch)
|
||||
end subroutine
|
||||
|
||||
! FIXME: coordinate of generated for derived%array_comp(i) are not zero based as they
|
||||
! should be.
|
||||
|
||||
! CHECK-LABEL: func @_QMdParray_comp_elt_ref(
|
||||
subroutine array_comp_elt_ref()
|
||||
type(r2) :: some_r2
|
||||
! CHECK: %[[alloc:.*]] = fir.alloca !fir.type<_QMdTr2{x_array:!fir.array<10x20xf32>}>
|
||||
! CHECK: %[[field:.*]] = fir.field_index x_array, !fir.type<_QMdTr2{x_array:!fir.array<10x20xf32>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[alloc]], %[[field]] : (!fir.ref<!fir.type<_QMdTr2{x_array:!fir.array<10x20xf32>}>>, !fir.field) -> !fir.ref<!fir.array<10x20xf32>>
|
||||
! CHECK-DAG: %[[index1:.*]] = arith.subi %c5{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK-DAG: %[[index2:.*]] = arith.subi %c6{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: fir.coordinate_of %[[coor]], %[[index1]], %[[index2]] : (!fir.ref<!fir.array<10x20xf32>>, i64, i64) -> !fir.ref<f32>
|
||||
call real_bar(some_r2%x_array(5, 6))
|
||||
end subroutine
|
||||
|
||||
|
||||
! CHECK-LABEL: func @_QMdPchar_array_comp_elt_ref(
|
||||
subroutine char_array_comp_elt_ref()
|
||||
type(c2) :: some_c2
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>>, !fir.field) -> !fir.ref<!fir.array<20x30x!fir.char<1,10>>>
|
||||
! CHECK-DAG: %[[index1:.*]] = arith.subi %c5{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK-DAG: %[[index2:.*]] = arith.subi %c6{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: fir.coordinate_of %[[coor]], %[[index1]], %[[index2]] : (!fir.ref<!fir.array<20x30x!fir.char<1,10>>>, i64, i64) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: fir.emboxchar %{{.*}}, %c10 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call char_bar(some_c2%ch_array(5, 6))
|
||||
end subroutine
|
||||
|
||||
! CHECK: @_QMdParray_elt_comp_ref
|
||||
subroutine array_elt_comp_ref()
|
||||
type(r) :: some_r_array(100)
|
||||
! CHECK: %[[alloca:.*]] = fir.alloca !fir.array<100x!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: %[[index:.*]] = arith.subi %c5{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: %[[elt:.*]] = fir.coordinate_of %[[alloca]], %[[index]] : (!fir.ref<!fir.array<100x!fir.type<_QMdTr{x:f32}>>>, i64) -> !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: %[[field:.*]] = fir.field_index x, !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: fir.coordinate_of %[[elt]], %[[field]] : (!fir.ref<!fir.type<_QMdTr{x:f32}>>, !fir.field) -> !fir.ref<f32>
|
||||
call real_bar(some_r_array(5)%x)
|
||||
end subroutine
|
||||
|
||||
! CHECK: @_QMdPchar_array_elt_comp_ref
|
||||
subroutine char_array_elt_comp_ref()
|
||||
type(c) :: some_c_array(100)
|
||||
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<100x!fir.type<_QMdTc{ch:!fir.char<1,10>}>>>, i64) -> !fir.ref<!fir.type<_QMdTc{ch:!fir.char<1,10>}>>
|
||||
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.type<_QMdTc{ch:!fir.char<1,10>}>>, !fir.field) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: fir.emboxchar %{{.*}}, %c10{{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call char_bar(some_c_array(5)%ch)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test loading derived type components
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! Most of the other tests only require lowering code to compute the address of
|
||||
! components. This one requires loading a component which tests other code paths
|
||||
! in lowering.
|
||||
|
||||
! CHECK-LABEL: func @_QMdPscalar_numeric_load(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
real function scalar_numeric_load(some_r)
|
||||
type(r) :: some_r
|
||||
! CHECK: %[[field:.*]] = fir.field_index x, !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[arg0]], %[[field]] : (!fir.ref<!fir.type<_QMdTr{x:f32}>>, !fir.field) -> !fir.ref<f32>
|
||||
! CHECK: fir.load %[[coor]]
|
||||
scalar_numeric_load = some_r%x
|
||||
end function
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test returned derived types (no length parameters)
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMdPbar_return_derived() -> !fir.type<_QMdTr{x:f32}>
|
||||
function bar_return_derived()
|
||||
! CHECK: %[[res:.*]] = fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
type(r) :: bar_return_derived
|
||||
! CHECK: %[[resLoad:.*]] = fir.load %[[res]] : !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: return %[[resLoad]] : !fir.type<_QMdTr{x:f32}>
|
||||
end function
|
||||
|
||||
! CHECK-LABEL: func @_QMdPcall_bar_return_derived(
|
||||
subroutine call_bar_return_derived()
|
||||
! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: %[[call:.*]] = fir.call @_QMdPbar_return_derived() : () -> !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK: fir.save_result %[[call]] to %[[tmp]] : !fir.type<_QMdTr{x:f32}>, !fir.ref<!fir.type<_QMdTr{x:f32}>>
|
||||
! CHECK: fir.call @_QPr_bar(%[[tmp]]) : (!fir.ref<!fir.type<_QMdTr{x:f32}>>) -> ()
|
||||
call r_bar(bar_return_derived())
|
||||
end subroutine
|
||||
|
||||
end module
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test derived type with pointer/allocatable components
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
module d2
|
||||
type recursive_t
|
||||
real :: x
|
||||
type(recursive_t), pointer :: ptr
|
||||
end type
|
||||
contains
|
||||
! CHECK-LABEL: func @_QMd2Ptest_recursive_type(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.type<_QMd2Trecursive_t{x:f32,ptr:!fir.box<!fir.ptr<!fir.type<_QMd2Trecursive_t>>>}>>{{.*}}) {
|
||||
subroutine test_recursive_type(some_recursive)
|
||||
type(recursive_t) :: some_recursive
|
||||
end subroutine
|
||||
end module
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test global derived type symbol lowering
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
module data_mod
|
||||
use d
|
||||
type(r) :: some_r
|
||||
type(c2) :: some_c2
|
||||
end module
|
||||
|
||||
! Test globals
|
||||
|
||||
! CHECK-DAG: fir.global @_QMdata_modEsome_c2 : !fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>
|
||||
! CHECK-DAG: fir.global @_QMdata_modEsome_r : !fir.type<_QMdTr{x:f32}>
|
||||
! CHECK-DAG: fir.global internal @_QMdFsaved_derivedEsome_c2 : !fir.type<_QMdTc2{ch_array:!fir.array<20x30x!fir.char<1,10>>}>
|
||||
! CHECK-DAG: fir.global internal @_QMdFsaved_derivedEsome_r : !fir.type<_QMdTr{x:f32}>
|
||||
|
|
|
|||
|
|
@ -2,426 +2,425 @@
|
|||
! explicit shapes (see F2018 15.5.2.12).
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
module optional_tests
|
||||
implicit none
|
||||
interface
|
||||
subroutine takes_opt_scalar(i)
|
||||
integer, optional :: i
|
||||
end subroutine
|
||||
subroutine takes_opt_scalar_char(c)
|
||||
character(*), optional :: c
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape(x)
|
||||
real, optional :: x(100)
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape_intentout(x)
|
||||
real, optional, intent(out) :: x(100)
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape_intentin(x)
|
||||
real, optional, intent(in) :: x(100)
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape_char(c)
|
||||
character(*), optional :: c(100)
|
||||
end subroutine
|
||||
function returns_pointer()
|
||||
real, pointer :: returns_pointer(:)
|
||||
end function
|
||||
end interface
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing scalar pointers and allocatables to an optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! Here, nothing optional specific is expected, the address is passed, and its
|
||||
! allocation/association status match the dummy presence status.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_scalar(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<i32>>>{{.*}}) {
|
||||
subroutine pass_pointer_scalar(i)
|
||||
integer, pointer :: i
|
||||
call takes_opt_scalar(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<i32>) -> !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar(%[[VAL_3]]) : (!fir.ref<i32>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_scalar(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<i32>>>{{.*}}) {
|
||||
subroutine pass_allocatable_scalar(i)
|
||||
integer, allocatable :: i
|
||||
call takes_opt_scalar(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<i32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.heap<i32>) -> !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar(%[[VAL_3]]) : (!fir.ref<i32>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_scalar_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}}) {
|
||||
subroutine pass_pointer_scalar_char(c)
|
||||
character(:), pointer :: c
|
||||
call takes_opt_scalar_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.char<1,?>>>) -> !fir.ptr<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ptr<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_scalar_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>{{.*}}) {
|
||||
subroutine pass_allocatable_scalar_char(c)
|
||||
character(:), allocatable :: c
|
||||
call takes_opt_scalar_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> !fir.heap<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing non contiguous pointers to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The pointer descriptor can be unconditionally read, but the copy-in/copy-out
|
||||
! must be conditional on the pointer association status in order to get the
|
||||
! correct present/absent aspect.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}) {
|
||||
subroutine pass_pointer_array(i)
|
||||
real, pointer :: i(:)
|
||||
call takes_opt_explicit_shape(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<!fir.array<?xf32>>) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.cmpi ne, %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_5]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_10]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array<?xf32>, %[[VAL_11]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_20:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_20]] to %[[VAL_12]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_12]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_26:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_26]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_9]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_29]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_5]] {
|
||||
! CHECK: %[[VAL_40:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_40]] to %[[VAL_6]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.freemem %[[VAL_9]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_array_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>{{.*}}) {
|
||||
subroutine pass_pointer_array_char(c)
|
||||
character(:), pointer :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.cmpi ne, %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_5]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_10]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_12:.*]] = fir.box_elesize %[[VAL_6]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_12]] : index), %[[VAL_11]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_21:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_21]] to %[[VAL_13]] typeparams %[[VAL_12]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.heap<!fir.array<?x!fir.char<1,?>>>, index
|
||||
! CHECK: fir.result %[[VAL_13]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_46:.*]] = fir.zero_bits !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.result %[[VAL_46]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_47:.*]] = fir.box_elesize %[[VAL_6]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_9]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_52:.*]] = fir.emboxchar %[[VAL_50]], %[[VAL_47]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_52]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: fir.if %[[VAL_5]] {
|
||||
! CHECK: %[[VAL_62:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_62]] to %[[VAL_6]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.freemem %[[VAL_9]]
|
||||
! CHECK: }
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! This case is bit special because the pointer is not a symbol but a function
|
||||
! result. Test that the copy-in/copy-out is the same as with normal pointers.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPforward_pointer_array() {
|
||||
subroutine forward_pointer_array()
|
||||
call takes_opt_explicit_shape(returns_pointer())
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xf32>>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_1:.*]] = fir.call @_QPreturns_pointer() : () -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.save_result %[[VAL_1]] to %[[VAL_0]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ptr<!fir.array<?xf32>>) -> i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = arith.cmpi ne, %[[VAL_4]], %[[VAL_5]] : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_6]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_11:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_11]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_14]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_6]] {
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.freemem %[[VAL_7]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing assumed shape optional to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can only be read if the assumed shape is present,
|
||||
! and the copy-in/copy-out must also be conditional on the assumed
|
||||
! shape presence.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape(x)
|
||||
real, optional :: x(:)
|
||||
call takes_opt_explicit_shape(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_8]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>, %[[VAL_9]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_17:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_17]] to %[[VAL_10]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_23:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_27:.*]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_26]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK: %[[VAL_36:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_36]] to %[[VAL_6]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: fir.freemem %[[VAL_27]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "c", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape_char(c)
|
||||
character(*), optional :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) typeparams %[[VAL_5]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_6]] : !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) {
|
||||
! CHECK: %[[VAL_19:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_19]] to %[[VAL_12]] typeparams %[[VAL_11]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.heap<!fir.array<?x!fir.char<1,?>>>, index
|
||||
! CHECK: fir.result %[[VAL_12]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_44:.*]] = fir.zero_bits !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.result %[[VAL_44]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_45:.*]] = fir.box_elesize %[[VAL_7]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_49:.*]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_50:.*]] = fir.emboxchar %[[VAL_48]], %[[VAL_45]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_50]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK: %[[VAL_59:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_59]] to %[[VAL_7]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.freemem %[[VAL_49]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing contiguous optional assumed shape to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can only be read if the assumed shape is present.
|
||||
! There should be no copy-in/copy-out
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_contiguous_assumed_shape(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.contiguous, fir.optional}) {
|
||||
subroutine pass_opt_contiguous_assumed_shape(x)
|
||||
real, optional, contiguous :: x(:)
|
||||
call takes_opt_explicit_shape(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_6]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.ref<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_8]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_contiguous_assumed_shape_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "c", fir.contiguous, fir.optional}) {
|
||||
subroutine pass_opt_contiguous_assumed_shape_char(c)
|
||||
character(*), optional, contiguous :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) typeparams %[[VAL_5]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_6]] : !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.box_elesize %[[VAL_7]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.emboxchar %[[VAL_10]], %[[VAL_9]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_11]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing allocatables and contiguous pointers to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can be read and its address directly passed. There should be no
|
||||
! copy-in/copy-out.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>{{.*}}) {
|
||||
subroutine pass_allocatable_array(i)
|
||||
real, allocatable :: i(:)
|
||||
call takes_opt_explicit_shape(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_3]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_array_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>{{.*}}) {
|
||||
subroutine pass_allocatable_array_char(c)
|
||||
character(:), allocatable :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_contiguous_pointer_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {fir.bindc_name = "i", fir.contiguous}) {
|
||||
subroutine pass_contiguous_pointer_array(i)
|
||||
real, pointer, contiguous :: i(:)
|
||||
call takes_opt_explicit_shape(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_3]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_contiguous_pointer_array_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>> {fir.bindc_name = "c", fir.contiguous}) {
|
||||
subroutine pass_contiguous_pointer_array_char(c)
|
||||
character(:), pointer, contiguous :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing assumed shape optional to explicit shape optional with intents
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can only be read if the assumed shape is present,
|
||||
! and the copy-in/copy-out must also be conditional on the assumed
|
||||
! shape presence. For intent(in), there should be no copy-out while for
|
||||
! intent(out), there should be no copy-in.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape_to_intentin(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape_to_intentin(x)
|
||||
real, optional :: x(:)
|
||||
call takes_opt_explicit_shape_intentin(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_23:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_intentin(%[[VAL_24]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK-NOT: fir.do_loop
|
||||
! CHECK: fir.freemem %[[VAL_7]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape_to_intentout(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape_to_intentout(x)
|
||||
real, optional :: x(:)
|
||||
call takes_opt_explicit_shape_intentout(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK-NOT: fir.do_loop
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_11:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_11]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_intentout(%[[VAL_14]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.freemem %[[VAL_7]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
end module
|
||||
|
||||
implicit none
|
||||
interface
|
||||
subroutine takes_opt_scalar(i)
|
||||
integer, optional :: i
|
||||
end subroutine
|
||||
subroutine takes_opt_scalar_char(c)
|
||||
character(*), optional :: c
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape(x)
|
||||
real, optional :: x(100)
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape_intentout(x)
|
||||
real, optional, intent(out) :: x(100)
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape_intentin(x)
|
||||
real, optional, intent(in) :: x(100)
|
||||
end subroutine
|
||||
subroutine takes_opt_explicit_shape_char(c)
|
||||
character(*), optional :: c(100)
|
||||
end subroutine
|
||||
function returns_pointer()
|
||||
real, pointer :: returns_pointer(:)
|
||||
end function
|
||||
end interface
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing scalar pointers and allocatables to an optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! Here, nothing optional specific is expected, the address is passed, and its
|
||||
! allocation/association status match the dummy presence status.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_scalar(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<i32>>>{{.*}}) {
|
||||
subroutine pass_pointer_scalar(i)
|
||||
integer, pointer :: i
|
||||
call takes_opt_scalar(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<i32>) -> !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar(%[[VAL_3]]) : (!fir.ref<i32>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_scalar(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<i32>>>{{.*}}) {
|
||||
subroutine pass_allocatable_scalar(i)
|
||||
integer, allocatable :: i
|
||||
call takes_opt_scalar(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<i32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.heap<i32>) -> !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar(%[[VAL_3]]) : (!fir.ref<i32>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_scalar_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}}) {
|
||||
subroutine pass_pointer_scalar_char(c)
|
||||
character(:), pointer :: c
|
||||
call takes_opt_scalar_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.char<1,?>>>) -> !fir.ptr<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ptr<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_scalar_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>{{.*}}) {
|
||||
subroutine pass_allocatable_scalar_char(c)
|
||||
character(:), allocatable :: c
|
||||
call takes_opt_scalar_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> !fir.heap<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_scalar_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing non contiguous pointers to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The pointer descriptor can be unconditionally read, but the copy-in/copy-out
|
||||
! must be conditional on the pointer association status in order to get the
|
||||
! correct present/absent aspect.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}) {
|
||||
subroutine pass_pointer_array(i)
|
||||
real, pointer :: i(:)
|
||||
call takes_opt_explicit_shape(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<!fir.array<?xf32>>) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.cmpi ne, %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_5]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_10]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array<?xf32>, %[[VAL_11]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_20:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_20]] to %[[VAL_12]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_12]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_26:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_26]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_9]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_29]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_5]] {
|
||||
! CHECK: %[[VAL_40:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_40]] to %[[VAL_6]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.freemem %[[VAL_9]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_pointer_array_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>{{.*}}) {
|
||||
subroutine pass_pointer_array_char(c)
|
||||
character(:), pointer :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.cmpi ne, %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_5]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_10]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_12:.*]] = fir.box_elesize %[[VAL_6]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_12]] : index), %[[VAL_11]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_21:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_21]] to %[[VAL_13]] typeparams %[[VAL_12]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.heap<!fir.array<?x!fir.char<1,?>>>, index
|
||||
! CHECK: fir.result %[[VAL_13]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_46:.*]] = fir.zero_bits !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.result %[[VAL_46]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_47:.*]] = fir.box_elesize %[[VAL_6]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_9]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_52:.*]] = fir.emboxchar %[[VAL_50]], %[[VAL_47]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_52]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: fir.if %[[VAL_5]] {
|
||||
! CHECK: %[[VAL_62:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_62]] to %[[VAL_6]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.freemem %[[VAL_9]]
|
||||
! CHECK: }
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! This case is bit special because the pointer is not a symbol but a function
|
||||
! result. Test that the copy-in/copy-out is the same as with normal pointers.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPforward_pointer_array() {
|
||||
subroutine forward_pointer_array()
|
||||
call takes_opt_explicit_shape(returns_pointer())
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xf32>>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_1:.*]] = fir.call @_QPreturns_pointer() : () -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.save_result %[[VAL_1]] to %[[VAL_0]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ptr<!fir.array<?xf32>>) -> i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = arith.cmpi ne, %[[VAL_4]], %[[VAL_5]] : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_6]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_11:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_11]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_14]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_6]] {
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.freemem %[[VAL_7]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing assumed shape optional to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can only be read if the assumed shape is present,
|
||||
! and the copy-in/copy-out must also be conditional on the assumed
|
||||
! shape presence.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape(x)
|
||||
real, optional :: x(:)
|
||||
call takes_opt_explicit_shape(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_8]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>, %[[VAL_9]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_17:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_17]] to %[[VAL_10]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_23:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_27:.*]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_26]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK: %[[VAL_36:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_36]] to %[[VAL_6]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: fir.freemem %[[VAL_27]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "c", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape_char(c)
|
||||
character(*), optional :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) typeparams %[[VAL_5]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_6]] : !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) {
|
||||
! CHECK: %[[VAL_19:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_19]] to %[[VAL_12]] typeparams %[[VAL_11]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.heap<!fir.array<?x!fir.char<1,?>>>, index
|
||||
! CHECK: fir.result %[[VAL_12]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_44:.*]] = fir.zero_bits !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.result %[[VAL_44]] : !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_45:.*]] = fir.box_elesize %[[VAL_7]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_49:.*]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_50:.*]] = fir.emboxchar %[[VAL_48]], %[[VAL_45]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_50]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK: %[[VAL_59:.*]] = fir.do_loop {{.*}} {
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %[[VAL_59]] to %[[VAL_7]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.freemem %[[VAL_49]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing contiguous optional assumed shape to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can only be read if the assumed shape is present.
|
||||
! There should be no copy-in/copy-out
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_contiguous_assumed_shape(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.contiguous, fir.optional}) {
|
||||
subroutine pass_opt_contiguous_assumed_shape(x)
|
||||
real, optional, contiguous :: x(:)
|
||||
call takes_opt_explicit_shape(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_6]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.ref<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_8]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_contiguous_assumed_shape_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "c", fir.contiguous, fir.optional}) {
|
||||
subroutine pass_opt_contiguous_assumed_shape_char(c)
|
||||
character(*), optional, contiguous :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) typeparams %[[VAL_5]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_6]] : !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.box_elesize %[[VAL_7]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_8]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.emboxchar %[[VAL_10]], %[[VAL_9]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_11]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing allocatables and contiguous pointers to explicit shape optional
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can be read and its address directly passed. There should be no
|
||||
! copy-in/copy-out.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>{{.*}}) {
|
||||
subroutine pass_allocatable_array(i)
|
||||
real, allocatable :: i(:)
|
||||
call takes_opt_explicit_shape(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_3]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_allocatable_array_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>{{.*}}) {
|
||||
subroutine pass_allocatable_array_char(c)
|
||||
character(:), allocatable :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> !fir.heap<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_contiguous_pointer_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {fir.bindc_name = "i", fir.contiguous}) {
|
||||
subroutine pass_contiguous_pointer_array(i)
|
||||
real, pointer, contiguous :: i(:)
|
||||
call takes_opt_explicit_shape(i)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape(%[[VAL_3]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_contiguous_pointer_array_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>> {fir.bindc_name = "c", fir.contiguous}) {
|
||||
subroutine pass_contiguous_pointer_array_char(c)
|
||||
character(:), pointer, contiguous :: c(:)
|
||||
call takes_opt_explicit_shape_char(c)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.emboxchar %[[VAL_4]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_char(%[[VAL_5]]) : (!fir.boxchar<1>) -> ()
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing assumed shape optional to explicit shape optional with intents
|
||||
! -----------------------------------------------------------------------------
|
||||
! The fix.box can only be read if the assumed shape is present,
|
||||
! and the copy-in/copy-out must also be conditional on the assumed
|
||||
! shape presence. For intent(in), there should be no copy-out while for
|
||||
! intent(out), there should be no copy-in.
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape_to_intentin(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape_to_intentin(x)
|
||||
real, optional :: x(:)
|
||||
call takes_opt_explicit_shape_intentin(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_23:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_intentin(%[[VAL_24]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK-NOT: fir.do_loop
|
||||
! CHECK: fir.freemem %[[VAL_7]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMoptional_testsPpass_opt_assumed_shape_to_intentout(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
|
||||
subroutine pass_opt_assumed_shape_to_intentout(x)
|
||||
real, optional :: x(:)
|
||||
call takes_opt_explicit_shape_intentout(x)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
|
||||
! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_2]](%[[VAL_4]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_1]], %[[VAL_0]], %[[VAL_5]] : !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.if %[[VAL_1]] -> (!fir.heap<!fir.array<?xf32>>) {
|
||||
! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK-NOT: fir.do_loop
|
||||
! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: } else {
|
||||
! CHECK: %[[VAL_11:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: fir.result %[[VAL_11]] : !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPtakes_opt_explicit_shape_intentout(%[[VAL_14]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
! CHECK: fir.if %[[VAL_1]] {
|
||||
! CHECK: fir.do_loop {{.*}} {
|
||||
! CHECK: }
|
||||
! CHECK: fir.freemem %[[VAL_7]]
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
end module
|
||||
|
|
|
|||
|
|
@ -8,247 +8,247 @@
|
|||
|
||||
! CHECK-LABEL: func @_QPcst_len
|
||||
subroutine cst_len()
|
||||
interface
|
||||
character(7) function bar1()
|
||||
end function
|
||||
end interface
|
||||
call foo1(bar1)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar1) : (!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_1]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo1(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
interface
|
||||
character(7) function bar1()
|
||||
end function
|
||||
end interface
|
||||
call foo1(bar1)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar1) : (!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_1]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo1(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcst_len_array
|
||||
subroutine cst_len_array()
|
||||
interface
|
||||
function bar1_array()
|
||||
character(7) :: bar1_array(10)
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar1_array) : () -> !fir.array<10x!fir.char<1,7>>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : (() -> !fir.array<10x!fir.char<1,7>>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_1]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo1b(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo1b(bar1_array)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcst_len_2
|
||||
subroutine cst_len_2()
|
||||
character(7) :: bar2
|
||||
external :: bar2
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar2) : (!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_1]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo2(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo2(bar2)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPdyn_len(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32>{{.*}}) {
|
||||
subroutine dyn_len(n)
|
||||
integer :: n
|
||||
character(n) :: bar3
|
||||
external :: bar3
|
||||
! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QPbar3) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.cmpi sgt, %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_5]], %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.emboxproc %[[VAL_1]] : ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_7]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.insert_value %[[VAL_9]], %[[VAL_6]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo3(%[[VAL_10]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo3(bar3)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcannot_compute_len_yet
|
||||
subroutine cannot_compute_len_yet()
|
||||
interface
|
||||
function bar4(n)
|
||||
integer :: n
|
||||
character(n) :: bar4
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar4) : (!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant -1 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_1]] : (index) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo4(%[[VAL_6]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo4(bar4)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcannot_compute_len_yet_2
|
||||
subroutine cannot_compute_len_yet_2()
|
||||
character(*) :: bar5
|
||||
external :: bar5
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar5) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant -1 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_1]] : (index) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo5(%[[VAL_6]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo5(bar5)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPforward_incoming_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine forward_incoming_length(bar6)
|
||||
character(*) :: bar6
|
||||
external :: bar6
|
||||
! CHECK: %[[VAL_1:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_2:.*]] = fir.extract_value %[[VAL_0]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
|
||||
! CHECK: %[[WAL_1:.*]] = fir.emboxproc %[[WAL_2]] : (() -> ()) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[WAL_1]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo6(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo6(bar6)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPoverride_incoming_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine override_incoming_length(bar7)
|
||||
character(7) :: bar7
|
||||
external :: bar7
|
||||
! CHECK: %[[VAL_1:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[WAL_1:.*]] = fir.emboxproc %[[WAL_2]] : (() -> ()) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[WAL_1]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo7(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo7(bar7)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test calling character dummy function
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QPcall_assumed_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine call_assumed_length(bar8)
|
||||
character(*) :: bar8
|
||||
external :: bar8
|
||||
! CHECK: %[[VAL_3:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_2:.*]] = fir.box_addr %[[VAL_3]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_4:.*]] = fir.extract_value %[[VAL_0]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_4]] : i64) {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[WAL_2]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>)
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
|
||||
! CHECK: fir.call %[[VAL_7]](%[[VAL_6]], %[[VAL_8]], %{{.*}}) : (!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>
|
||||
call test(bar8(42))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcall_explicit_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine call_explicit_length(bar9)
|
||||
character(7) :: bar9
|
||||
external :: bar9
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<1,7> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_4:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_4]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,7>>, index, !fir.ref<i32>) -> !fir.boxchar<1>)
|
||||
! CHECK: fir.call %[[VAL_8]](%[[VAL_1]], %[[VAL_6]], %{{.*}}) : (!fir.ref<!fir.char<1,7>>, index, !fir.ref<i32>) -> !fir.boxchar<1>
|
||||
call test(bar9(42))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcall_explicit_length_with_iface
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine call_explicit_length_with_iface(bar10)
|
||||
interface
|
||||
function bar10(n)
|
||||
integer(8) :: n
|
||||
character(n) :: bar10
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca i64
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 42 : i64
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<i64>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_3]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_1]] : !fir.ref<i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.call @llvm.stacksave() : () -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_5]] : index) {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index, !fir.ref<i64>) -> !fir.boxchar<1>)
|
||||
! CHECK: fir.call %[[VAL_8]](%[[VAL_7]], %[[VAL_5]], %[[VAL_1]]) : (!fir.ref<!fir.char<1,?>>, index, !fir.ref<i64>) -> !fir.boxchar<1>
|
||||
call test(bar10(42_8))
|
||||
end subroutine
|
||||
|
||||
|
||||
! CHECK-LABEL: func @_QPhost(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64>
|
||||
subroutine host(f)
|
||||
character*(*) :: f
|
||||
external :: f
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1:.*]], %{{.*}} : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.store %[[VAL_0]] to %[[VAL_3]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.call @_QFhostPintern(%[[VAL_1]])
|
||||
call intern()
|
||||
contains
|
||||
! CHECK-LABEL: func @_QFhostPintern(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>> {fir.host_assoc})
|
||||
subroutine intern()
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 0 : i32
|
||||
! CHECK: %[[VAL_2:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_1]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.extract_value %[[VAL_3]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_4]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_5:.*]] = fir.extract_value %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_5]] : i64) {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>)
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: fir.call %[[VAL_8]](%[[VAL_7]], %[[VAL_9]]) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call test(f())
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcst_len_array
|
||||
subroutine cst_len_array()
|
||||
interface
|
||||
function bar1_array()
|
||||
character(7) :: bar1_array(10)
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar1_array) : () -> !fir.array<10x!fir.char<1,7>>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : (() -> !fir.array<10x!fir.char<1,7>>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_1]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo1b(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo1b(bar1_array)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcst_len_2
|
||||
subroutine cst_len_2()
|
||||
character(7) :: bar2
|
||||
external :: bar2
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar2) : (!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_1]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo2(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo2(bar2)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPdyn_len(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32>{{.*}}) {
|
||||
subroutine dyn_len(n)
|
||||
integer :: n
|
||||
character(n) :: bar3
|
||||
external :: bar3
|
||||
! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QPbar3) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.cmpi sgt, %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_5]], %[[VAL_3]], %[[VAL_4]] : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.emboxproc %[[VAL_1]] : ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_7]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.insert_value %[[VAL_9]], %[[VAL_6]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo3(%[[VAL_10]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo3(bar3)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcannot_compute_len_yet
|
||||
subroutine cannot_compute_len_yet()
|
||||
interface
|
||||
function bar4(n)
|
||||
integer :: n
|
||||
character(n) :: bar4
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar4) : (!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant -1 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_1]] : (index) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo4(%[[VAL_6]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo4(bar4)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcannot_compute_len_yet_2
|
||||
subroutine cannot_compute_len_yet_2()
|
||||
character(*) :: bar5
|
||||
external :: bar5
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QPbar5) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant -1 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_1]] : (index) -> i64
|
||||
! CHECK: %[[VAL_4:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo5(%[[VAL_6]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo5(bar5)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPforward_incoming_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine forward_incoming_length(bar6)
|
||||
character(*) :: bar6
|
||||
external :: bar6
|
||||
! CHECK: %[[VAL_1:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_2:.*]] = fir.extract_value %[[VAL_0]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
|
||||
! CHECK: %[[WAL_1:.*]] = fir.emboxproc %[[WAL_2]] : (() -> ()) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[WAL_1]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo6(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo6(bar6)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPoverride_incoming_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine override_incoming_length(bar7)
|
||||
character(7) :: bar7
|
||||
external :: bar7
|
||||
! CHECK: %[[VAL_1:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[WAL_1:.*]] = fir.emboxproc %[[WAL_2]] : (() -> ()) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[WAL_1]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
|
||||
! CHECK: fir.call @_QPfoo7(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
|
||||
call foo7(bar7)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test calling character dummy function
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QPcall_assumed_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine call_assumed_length(bar8)
|
||||
character(*) :: bar8
|
||||
external :: bar8
|
||||
! CHECK: %[[VAL_3:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_2:.*]] = fir.box_addr %[[VAL_3]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_4:.*]] = fir.extract_value %[[VAL_0]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_4]] : i64) {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[WAL_2]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>)
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
|
||||
! CHECK: fir.call %[[VAL_7]](%[[VAL_6]], %[[VAL_8]], %{{.*}}) : (!fir.ref<!fir.char<1,?>>, index, !fir.ref<i32>) -> !fir.boxchar<1>
|
||||
call test(bar8(42))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcall_explicit_length
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine call_explicit_length(bar9)
|
||||
character(7) :: bar9
|
||||
external :: bar9
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<1,7> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_4:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_4]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 7 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,7>>, index, !fir.ref<i32>) -> !fir.boxchar<1>)
|
||||
! CHECK: fir.call %[[VAL_8]](%[[VAL_1]], %[[VAL_6]], %{{.*}}) : (!fir.ref<!fir.char<1,7>>, index, !fir.ref<i32>) -> !fir.boxchar<1>
|
||||
call test(bar9(42))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPcall_explicit_length_with_iface
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc}) {
|
||||
subroutine call_explicit_length_with_iface(bar10)
|
||||
interface
|
||||
function bar10(n)
|
||||
integer(8) :: n
|
||||
character(n) :: bar10
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca i64
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 42 : i64
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<i64>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.extract_value %[[VAL_0]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_3]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_1]] : !fir.ref<i64>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.call @llvm.stacksave() : () -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_5]] : index) {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index, !fir.ref<i64>) -> !fir.boxchar<1>)
|
||||
! CHECK: fir.call %[[VAL_8]](%[[VAL_7]], %[[VAL_5]], %[[VAL_1]]) : (!fir.ref<!fir.char<1,?>>, index, !fir.ref<i64>) -> !fir.boxchar<1>
|
||||
call test(bar10(42_8))
|
||||
end subroutine
|
||||
|
||||
|
||||
! CHECK-LABEL: func @_QPhost(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64>
|
||||
subroutine host(f)
|
||||
character*(*) :: f
|
||||
external :: f
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1:.*]], %{{.*}} : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.store %[[VAL_0]] to %[[VAL_3]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.call @_QFhostPintern(%[[VAL_1]])
|
||||
call intern()
|
||||
contains
|
||||
! CHECK-LABEL: func @_QFhostPintern(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>> {fir.host_assoc})
|
||||
subroutine intern()
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 0 : i32
|
||||
! CHECK: %[[VAL_2:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_1]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.extract_value %[[VAL_3]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_4]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_5:.*]] = fir.extract_value %[[VAL_3]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_5]] : i64) {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>)
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: fir.call %[[VAL_8]](%[[VAL_7]], %[[VAL_9]]) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
call test(f())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPhost2(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc})
|
||||
subroutine host2(f)
|
||||
! Test that dummy length is overridden by local length even when used
|
||||
! in the internal procedure.
|
||||
character*(42) :: f
|
||||
external :: f
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1:.*]], %{{.*}} : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.store %[[VAL_0]] to %[[VAL_3]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.call @_QFhost2Pintern(%[[VAL_1]])
|
||||
call intern()
|
||||
contains
|
||||
! CHECK-LABEL: func @_QFhost2Pintern(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>> {fir.host_assoc})
|
||||
subroutine intern()
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<1,42> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_3]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.extract_value %[[VAL_4]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_5]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 42 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,42>>, index) -> !fir.boxchar<1>)
|
||||
! CHECK: fir.call %[[VAL_9]](%[[VAL_1]], %[[VAL_7]]) : (!fir.ref<!fir.char<1,42>>, index) -> !fir.boxchar<1>
|
||||
call test(f())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPhost2(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: tuple<!fir.boxproc<() -> ()>, i64> {fir.char_proc})
|
||||
subroutine host2(f)
|
||||
! Test that dummy length is overridden by local length even when used
|
||||
! in the internal procedure.
|
||||
character*(42) :: f
|
||||
external :: f
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1:.*]], %{{.*}} : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.store %[[VAL_0]] to %[[VAL_3]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: fir.call @_QFhost2Pintern(%[[VAL_1]])
|
||||
call intern()
|
||||
contains
|
||||
! CHECK-LABEL: func @_QFhost2Pintern(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>> {fir.host_assoc})
|
||||
subroutine intern()
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<1,42> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<tuple<tuple<!fir.boxproc<() -> ()>, i64>>>, i32) -> !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_3]] : !fir.ref<tuple<!fir.boxproc<() -> ()>, i64>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.extract_value %[[VAL_4]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxproc<() -> ()>
|
||||
! CHECK: %[[WAL_1:.*]] = fir.box_addr %[[VAL_5]] : (!fir.boxproc<() -> ()>) -> (() -> ())
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 42 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[WAL_1]] : (() -> ()) -> ((!fir.ref<!fir.char<1,42>>, index) -> !fir.boxchar<1>)
|
||||
! CHECK: fir.call %[[VAL_9]](%[[VAL_1]], %[[VAL_7]]) : (!fir.ref<!fir.char<1,42>>, index) -> !fir.boxchar<1>
|
||||
call test(f())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
|
|
|||
|
|
@ -4,155 +4,155 @@
|
|||
! CHECK-LABEL: func @_QPcompare1(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.logical<4>>{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) {
|
||||
subroutine compare1(x, c1, c2)
|
||||
character(*) c1, c2, d1, d2
|
||||
logical x, y
|
||||
x = c1 < c2
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPcompare2(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.logical<4>>{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) {
|
||||
entry compare2(y, d2, d1)
|
||||
y = d1 < d2
|
||||
end
|
||||
|
||||
program entries
|
||||
character(10) hh, qq, m
|
||||
character(len=4) s1, s2
|
||||
integer mm
|
||||
logical r
|
||||
s1 = 'a111'
|
||||
s2 = 'a222'
|
||||
call compare1(r, s1, s2); print*, r
|
||||
call compare2(r, s1, s2); print*, r
|
||||
call ss(mm); print*, mm
|
||||
call e1(mm, 17); print*, mm
|
||||
call e2(17, mm); print*, mm
|
||||
call e3(mm); print*, mm
|
||||
print*, jj(11)
|
||||
print*, rr(22)
|
||||
m = 'abcd efgh'
|
||||
print*, hh(m)
|
||||
print*, qq(m)
|
||||
call dd1
|
||||
call dd2
|
||||
call dd3(6)
|
||||
6 continue
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPss(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
subroutine ss(n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
integer n17, n2
|
||||
nx = 100
|
||||
n1 = nx + 10
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPe1(
|
||||
character(*) c1, c2, d1, d2
|
||||
logical x, y
|
||||
x = c1 < c2
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPcompare2(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.logical<4>>{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) {
|
||||
entry compare2(y, d2, d1)
|
||||
y = d1 < d2
|
||||
end
|
||||
|
||||
program entries
|
||||
character(10) hh, qq, m
|
||||
character(len=4) s1, s2
|
||||
integer mm
|
||||
logical r
|
||||
s1 = 'a111'
|
||||
s2 = 'a222'
|
||||
call compare1(r, s1, s2); print*, r
|
||||
call compare2(r, s1, s2); print*, r
|
||||
call ss(mm); print*, mm
|
||||
call e1(mm, 17); print*, mm
|
||||
call e2(17, mm); print*, mm
|
||||
call e3(mm); print*, mm
|
||||
print*, jj(11)
|
||||
print*, rr(22)
|
||||
m = 'abcd efgh'
|
||||
print*, hh(m)
|
||||
print*, qq(m)
|
||||
call dd1
|
||||
call dd2
|
||||
call dd3(6)
|
||||
6 continue
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPss(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
subroutine ss(n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
integer n17, n2
|
||||
nx = 100
|
||||
n1 = nx + 10
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPe1(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}, %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
entry e1(n2, n17)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
ny = 200
|
||||
n2 = ny + 20
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPe2(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}, %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
entry e1(n2, n17)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
ny = 200
|
||||
n2 = ny + 20
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPe2(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}, %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
entry e2(n3, n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
|
||||
! CHECK-LABEL: func @_QPe3(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
entry e3(n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
n1 = 30
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPjj(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) -> i32
|
||||
function jj(n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Ejj"}
|
||||
jj = 100
|
||||
jj = jj + n1
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPrr(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) -> f32
|
||||
entry rr(n2)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Ejj"}
|
||||
rr = 200.0
|
||||
rr = rr + n2
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPhh(
|
||||
entry e2(n3, n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
|
||||
! CHECK-LABEL: func @_QPe3(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) {
|
||||
entry e3(n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Enx"}
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Eny"}
|
||||
n1 = 30
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPjj(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) -> i32
|
||||
function jj(n1)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Ejj"}
|
||||
jj = 100
|
||||
jj = jj + n1
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPrr(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}) -> f32
|
||||
entry rr(n2)
|
||||
! CHECK: fir.alloca i32 {{{.*}}uniq_name = "{{.*}}Ejj"}
|
||||
rr = 200.0
|
||||
rr = rr + n2
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPhh(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.char<1,10>>{{.*}}, %{{.*}}: index{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) -> !fir.boxchar<1>
|
||||
function hh(c1)
|
||||
character(10) c1, hh, qq
|
||||
hh = c1
|
||||
return
|
||||
! CHECK-LABEL: func @_QPqq(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.char<1,10>>{{.*}}, %{{.*}}: index{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) -> !fir.boxchar<1>
|
||||
function hh(c1)
|
||||
character(10) c1, hh, qq
|
||||
hh = c1
|
||||
return
|
||||
! CHECK-LABEL: func @_QPqq(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.char<1,10>>{{.*}}, %{{.*}}: index{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) -> !fir.boxchar<1>
|
||||
entry qq(c1)
|
||||
qq = c1
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPchar_array()
|
||||
function char_array()
|
||||
character(10), c(5)
|
||||
! CHECK-LABEL: func @_QPchar_array_entry(
|
||||
! CHECK-SAME: %{{.*}}: !fir.boxchar<1>{{.*}}) -> f32 {
|
||||
entry char_array_entry(c)
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPdd1()
|
||||
subroutine dd1
|
||||
! CHECK: %[[kk:[0-9]*]] = fir.alloca i32 {bindc_name = "kk", uniq_name =
|
||||
! "_QFdd1Ekk"}
|
||||
! CHECK: br ^bb1
|
||||
! CHECK: ^bb1: // pred: ^bb0
|
||||
! CHECK: %[[ten:.*]] = arith.constant 10 : i32
|
||||
! CHECK: fir.store %[[ten:.*]] to %[[kk]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb2
|
||||
! CHECK: ^bb2: // pred: ^bb1
|
||||
! CHECK: %[[twenty:.*]] = arith.constant 20 : i32
|
||||
! CHECK: fir.store %[[twenty:.*]] to %[[kk]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb3
|
||||
! CHECK: ^bb3: // pred: ^bb2
|
||||
! CHECK: return
|
||||
kk = 10
|
||||
|
||||
! CHECK-LABEL: func @_QPdd2()
|
||||
! CHECK: %[[kk:[0-9]*]] = fir.alloca i32 {bindc_name = "kk", uniq_name =
|
||||
! "_QFdd1Ekk"}
|
||||
! CHECK: br ^bb1
|
||||
! CHECK: ^bb1: // pred: ^bb0
|
||||
! CHECK: %[[twenty:.*]] = arith.constant 20 : i32
|
||||
! CHECK: fir.store %[[twenty:.*]] to %[[kk]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb2
|
||||
! CHECK: ^bb2: // pred: ^bb1
|
||||
! CHECK: return
|
||||
entry dd2
|
||||
kk = 20
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPdd3
|
||||
! CHECK: %[[dd3:[0-9]*]] = fir.alloca index {bindc_name = "dd3"}
|
||||
! CHECK: %[[kk:[0-9]*]] = fir.alloca i32 {bindc_name = "kk", uniq_name =
|
||||
! "_QFdd1Ekk"}
|
||||
! CHECK: %[[zero:.*]] = arith.constant 0 : index
|
||||
! CHECK: fir.store %[[zero:.*]] to %[[dd3]] : !fir.ref<index>
|
||||
! CHECK: br ^bb1
|
||||
! CHECK: ^bb1: // pred: ^bb0
|
||||
! CHECK: %[[thirty:.*]] = arith.constant 30 : i32
|
||||
! CHECK: fir.store %[[thirty:.*]] to %[[kk:[0-9]*]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb2
|
||||
! CHECK: ^bb2: // pred: ^bb1
|
||||
! CHECK: %[[altret:[0-9]*]] = fir.load %[[dd3]] : !fir.ref<index>
|
||||
! CHECK: return %[[altret:[0-9]*]] : index
|
||||
entry dd3(*)
|
||||
kk = 30
|
||||
end
|
||||
entry qq(c1)
|
||||
qq = c1
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPchar_array()
|
||||
function char_array()
|
||||
character(10), c(5)
|
||||
! CHECK-LABEL: func @_QPchar_array_entry(
|
||||
! CHECK-SAME: %{{.*}}: !fir.boxchar<1>{{.*}}) -> f32 {
|
||||
entry char_array_entry(c)
|
||||
end
|
||||
|
||||
! CHECK-LABEL: func @_QPdd1()
|
||||
subroutine dd1
|
||||
! CHECK: %[[kk:[0-9]*]] = fir.alloca i32 {bindc_name = "kk", uniq_name =
|
||||
! "_QFdd1Ekk"}
|
||||
! CHECK: br ^bb1
|
||||
! CHECK: ^bb1: // pred: ^bb0
|
||||
! CHECK: %[[ten:.*]] = arith.constant 10 : i32
|
||||
! CHECK: fir.store %[[ten:.*]] to %[[kk]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb2
|
||||
! CHECK: ^bb2: // pred: ^bb1
|
||||
! CHECK: %[[twenty:.*]] = arith.constant 20 : i32
|
||||
! CHECK: fir.store %[[twenty:.*]] to %[[kk]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb3
|
||||
! CHECK: ^bb3: // pred: ^bb2
|
||||
! CHECK: return
|
||||
kk = 10
|
||||
|
||||
! CHECK-LABEL: func @_QPdd2()
|
||||
! CHECK: %[[kk:[0-9]*]] = fir.alloca i32 {bindc_name = "kk", uniq_name =
|
||||
! "_QFdd1Ekk"}
|
||||
! CHECK: br ^bb1
|
||||
! CHECK: ^bb1: // pred: ^bb0
|
||||
! CHECK: %[[twenty:.*]] = arith.constant 20 : i32
|
||||
! CHECK: fir.store %[[twenty:.*]] to %[[kk]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb2
|
||||
! CHECK: ^bb2: // pred: ^bb1
|
||||
! CHECK: return
|
||||
entry dd2
|
||||
kk = 20
|
||||
return
|
||||
|
||||
! CHECK-LABEL: func @_QPdd3
|
||||
! CHECK: %[[dd3:[0-9]*]] = fir.alloca index {bindc_name = "dd3"}
|
||||
! CHECK: %[[kk:[0-9]*]] = fir.alloca i32 {bindc_name = "kk", uniq_name =
|
||||
! "_QFdd1Ekk"}
|
||||
! CHECK: %[[zero:.*]] = arith.constant 0 : index
|
||||
! CHECK: fir.store %[[zero:.*]] to %[[dd3]] : !fir.ref<index>
|
||||
! CHECK: br ^bb1
|
||||
! CHECK: ^bb1: // pred: ^bb0
|
||||
! CHECK: %[[thirty:.*]] = arith.constant 30 : i32
|
||||
! CHECK: fir.store %[[thirty:.*]] to %[[kk:[0-9]*]] : !fir.ref<i32>
|
||||
! CHECK: br ^bb2
|
||||
! CHECK: ^bb2: // pred: ^bb1
|
||||
! CHECK: %[[altret:[0-9]*]] = fir.load %[[dd3]] : !fir.ref<index>
|
||||
! CHECK: return %[[altret:[0-9]*]] : index
|
||||
entry dd3(*)
|
||||
kk = 30
|
||||
end
|
||||
|
|
|
|||
|
|
@ -4,95 +4,94 @@
|
|||
|
||||
!*** Test a FORALL construct
|
||||
subroutine test_forall_construct(a,b)
|
||||
integer :: i, j
|
||||
real :: a(:,:), b(:,:)
|
||||
forall (i=1:ubound(a,1), j=1:ubound(a,2), b(j,i) > 0.0)
|
||||
a(i,j) = b(j,i) / 3.14
|
||||
end forall
|
||||
end subroutine test_forall_construct
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_forall_construct(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) {
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "j"}
|
||||
! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 1 : i32
|
||||
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> index
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_6]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]]#1 : (index) -> i64
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (index) -> i64
|
||||
! CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_8]], %[[VAL_10]] : i64
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_13:.*]] = arith.subi %[[VAL_11]], %[[VAL_12]] : i64
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> i32
|
||||
! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i32) -> index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i32
|
||||
! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (i32) -> index
|
||||
! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_19]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]]#1 : (index) -> i64
|
||||
! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (index) -> i64
|
||||
! CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_21]], %[[VAL_23]] : i64
|
||||
! CHECK: %[[VAL_25:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_24]], %[[VAL_25]] : i64
|
||||
! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> i32
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i32) -> index
|
||||
! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.array<?x?xf32>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.array<?x?xf32>
|
||||
! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %[[VAL_5]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_34:.*]] = %[[VAL_30]]) -> (!fir.array<?x?xf32>) {
|
||||
! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_33]] : (index) -> i32
|
||||
! CHECK: fir.store %[[VAL_35]] to %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_18]] to %[[VAL_28]] step %[[VAL_29]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_34]]) -> (!fir.array<?x?xf32>) {
|
||||
! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (index) -> i32
|
||||
! CHECK: fir.store %[[VAL_39]] to %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_42:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_41]], %[[VAL_42]] : i64
|
||||
! CHECK: %[[VAL_44:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_46:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_45]], %[[VAL_46]] : i64
|
||||
! CHECK: %[[VAL_48:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_43]], %[[VAL_47]] : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
|
||||
! CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_48]] : !fir.ref<f32>
|
||||
! CHECK: %[[VAL_50:.*]] = arith.constant 0.000000e+00 : f32
|
||||
! CHECK: %[[VAL_51:.*]] = arith.cmpf ogt, %[[VAL_49]], %[[VAL_50]] : f32
|
||||
! CHECK: %[[VAL_52:.*]] = fir.if %[[VAL_51]] -> (!fir.array<?x?xf32>) {
|
||||
! CHECK: %[[VAL_53:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_54:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_54]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_55]] : (i64) -> index
|
||||
! CHECK: %[[VAL_57:.*]] = arith.subi %[[VAL_56]], %[[VAL_53]] : index
|
||||
! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i64) -> index
|
||||
! CHECK: %[[VAL_61:.*]] = arith.subi %[[VAL_60]], %[[VAL_53]] : index
|
||||
! CHECK: %[[VAL_62:.*]] = arith.constant 3.140000e+00 : f32
|
||||
! CHECK: %[[VAL_63:.*]] = fir.array_fetch %[[VAL_31]], %[[VAL_57]], %[[VAL_61]] : (!fir.array<?x?xf32>, index, index) -> f32
|
||||
! CHECK: %[[VAL_64:.*]] = arith.divf %[[VAL_63]], %[[VAL_62]] : f32
|
||||
! CHECK: %[[VAL_65:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_66:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_66]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_67]] : (i64) -> index
|
||||
! CHECK: %[[VAL_69:.*]] = arith.subi %[[VAL_68]], %[[VAL_65]] : index
|
||||
! CHECK: %[[VAL_70:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_71:.*]] = fir.convert %[[VAL_70]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_71]] : (i64) -> index
|
||||
! CHECK: %[[VAL_73:.*]] = arith.subi %[[VAL_72]], %[[VAL_65]] : index
|
||||
! CHECK: %[[VAL_74:.*]] = fir.array_update %[[VAL_38]], %[[VAL_64]], %[[VAL_69]], %[[VAL_73]] : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
|
||||
! CHECK: fir.result %[[VAL_74]] : !fir.array<?x?xf32>
|
||||
! CHECK: } else {
|
||||
! CHECK: fir.result %[[VAL_38]] : !fir.array<?x?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_75:.*]] : !fir.array<?x?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_76:.*]] : !fir.array<?x?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_30]], %[[VAL_77:.*]] to %[[VAL_0]] : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.box<!fir.array<?x?xf32>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
integer :: i, j
|
||||
real :: a(:,:), b(:,:)
|
||||
forall (i=1:ubound(a,1), j=1:ubound(a,2), b(j,i) > 0.0)
|
||||
a(i,j) = b(j,i) / 3.14
|
||||
end forall
|
||||
end subroutine test_forall_construct
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_forall_construct(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) {
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "j"}
|
||||
! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 1 : i32
|
||||
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> index
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_6]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]]#1 : (index) -> i64
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (index) -> i64
|
||||
! CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_8]], %[[VAL_10]] : i64
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_13:.*]] = arith.subi %[[VAL_11]], %[[VAL_12]] : i64
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> i32
|
||||
! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i32) -> index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i32
|
||||
! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (i32) -> index
|
||||
! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_19]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]]#1 : (index) -> i64
|
||||
! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (index) -> i64
|
||||
! CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_21]], %[[VAL_23]] : i64
|
||||
! CHECK: %[[VAL_25:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_24]], %[[VAL_25]] : i64
|
||||
! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> i32
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i32) -> index
|
||||
! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.array<?x?xf32>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.array<?x?xf32>
|
||||
! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %[[VAL_5]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_34:.*]] = %[[VAL_30]]) -> (!fir.array<?x?xf32>) {
|
||||
! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_33]] : (index) -> i32
|
||||
! CHECK: fir.store %[[VAL_35]] to %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_18]] to %[[VAL_28]] step %[[VAL_29]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_34]]) -> (!fir.array<?x?xf32>) {
|
||||
! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (index) -> i32
|
||||
! CHECK: fir.store %[[VAL_39]] to %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_42:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_41]], %[[VAL_42]] : i64
|
||||
! CHECK: %[[VAL_44:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_46:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_45]], %[[VAL_46]] : i64
|
||||
! CHECK: %[[VAL_48:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_43]], %[[VAL_47]] : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
|
||||
! CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_48]] : !fir.ref<f32>
|
||||
! CHECK: %[[VAL_50:.*]] = arith.constant 0.000000e+00 : f32
|
||||
! CHECK: %[[VAL_51:.*]] = arith.cmpf ogt, %[[VAL_49]], %[[VAL_50]] : f32
|
||||
! CHECK: %[[VAL_52:.*]] = fir.if %[[VAL_51]] -> (!fir.array<?x?xf32>) {
|
||||
! CHECK: %[[VAL_53:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_54:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_54]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_55]] : (i64) -> index
|
||||
! CHECK: %[[VAL_57:.*]] = arith.subi %[[VAL_56]], %[[VAL_53]] : index
|
||||
! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i64) -> index
|
||||
! CHECK: %[[VAL_61:.*]] = arith.subi %[[VAL_60]], %[[VAL_53]] : index
|
||||
! CHECK: %[[VAL_62:.*]] = arith.constant 3.140000e+00 : f32
|
||||
! CHECK: %[[VAL_63:.*]] = fir.array_fetch %[[VAL_31]], %[[VAL_57]], %[[VAL_61]] : (!fir.array<?x?xf32>, index, index) -> f32
|
||||
! CHECK: %[[VAL_64:.*]] = arith.divf %[[VAL_63]], %[[VAL_62]] : f32
|
||||
! CHECK: %[[VAL_65:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_66:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_66]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_67]] : (i64) -> index
|
||||
! CHECK: %[[VAL_69:.*]] = arith.subi %[[VAL_68]], %[[VAL_65]] : index
|
||||
! CHECK: %[[VAL_70:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_71:.*]] = fir.convert %[[VAL_70]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_71]] : (i64) -> index
|
||||
! CHECK: %[[VAL_73:.*]] = arith.subi %[[VAL_72]], %[[VAL_65]] : index
|
||||
! CHECK: %[[VAL_74:.*]] = fir.array_update %[[VAL_38]], %[[VAL_64]], %[[VAL_69]], %[[VAL_73]] : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
|
||||
! CHECK: fir.result %[[VAL_74]] : !fir.array<?x?xf32>
|
||||
! CHECK: } else {
|
||||
! CHECK: fir.result %[[VAL_38]] : !fir.array<?x?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_75:.*]] : !fir.array<?x?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_76:.*]] : !fir.array<?x?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_30]], %[[VAL_77:.*]] to %[[VAL_0]] : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.box<!fir.array<?x?xf32>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
|
|
|||
|
|
@ -10,42 +10,42 @@
|
|||
! CHECK-LABEL: func @_QPtest_scalar(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{.*}})
|
||||
subroutine test_scalar(p)
|
||||
real, pointer :: p
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
nullify(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}})
|
||||
subroutine test_scalar_char(p)
|
||||
character(:), pointer :: p
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.char<1,?>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]] typeparams %c0{{.*}} : (!fir.ptr<!fir.char<1,?>>, index) -> !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
nullify(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_array(p)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c0{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
nullify(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_list(
|
||||
! CHECK-SAME: %[[p1:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{.*}}, %[[p2:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_list(p1, p2)
|
||||
real, pointer :: p1, p2(:)
|
||||
! CHECK: fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: fir.store %{{.*}} to %[[p1]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
|
||||
! CHECK: fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: fir.store %{{.*}} to %[[p2]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
nullify(p1, p2)
|
||||
end subroutine
|
||||
real, pointer :: p
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
nullify(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}})
|
||||
subroutine test_scalar_char(p)
|
||||
character(:), pointer :: p
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.char<1,?>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]] typeparams %c0{{.*}} : (!fir.ptr<!fir.char<1,?>>, index) -> !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
nullify(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_array(p)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c0{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
nullify(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_list(
|
||||
! CHECK-SAME: %[[p1:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{.*}}, %[[p2:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_list(p1, p2)
|
||||
real, pointer :: p1, p2(:)
|
||||
! CHECK: fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: fir.store %{{.*}} to %[[p1]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
|
||||
! CHECK: fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: fir.store %{{.*}} to %[[p2]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
nullify(p1, p2)
|
||||
end subroutine
|
||||
|
|
|
|||
|
|
@ -4,32 +4,31 @@
|
|||
! Format (Fortran 2018 12.6.2.2 point 3)
|
||||
! CHECK-LABEL: func @_QPtest_array_format
|
||||
subroutine test_array_format
|
||||
! CHECK-DAG: %[[c2:.*]] = arith.constant 2 : index
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 : index
|
||||
! CHECK-DAG: %[[mem:.*]] = fir.alloca !fir.array<2x!fir.char<1,10>>
|
||||
character(10) :: array(2)
|
||||
array(1) ="(15HThis i"
|
||||
array(2) ="s a test.)"
|
||||
! CHECK-DAG: %[[fmtLen:.*]] = arith.muli %[[c10]], %[[c2]] : index
|
||||
! CHECK-DAG: %[[scalarFmt:.*]] = fir.convert %[[mem]] : (!fir.ref<!fir.array<2x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK-DAG: %[[fmtArg:.*]] = fir.convert %[[scalarFmt]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
|
||||
! CHECK-DAG: %[[fmtLenArg:.*]] = fir.convert %[[fmtLen]] : (index) -> i64
|
||||
! CHECK: fir.call @_FortranAioBeginExternalFormattedOutput(%[[fmtArg]], %[[fmtLenArg]], {{.*}})
|
||||
write(*, array)
|
||||
end subroutine
|
||||
|
||||
! A test to check the buffer and it's length.
|
||||
! CHECK-LABEL: @_QPsome
|
||||
subroutine some()
|
||||
character(LEN=255):: buffer
|
||||
character(LEN=255):: greeting
|
||||
10 format (A255)
|
||||
! CHECK: fir.address_of(@_QQcl.636F6D70696C6572) :
|
||||
write (buffer, 10) "compiler"
|
||||
read (buffer, 10) greeting
|
||||
end
|
||||
! CHECK-LABEL: fir.global linkonce @_QQcl.636F6D70696C6572
|
||||
! CHECK: %[[lit:.*]] = fir.string_lit "compiler"(8) : !fir.char<1,8>
|
||||
! CHECK: fir.has_value %[[lit]] : !fir.char<1,8>
|
||||
! CHECK: }
|
||||
|
||||
! CHECK-DAG: %[[c2:.*]] = arith.constant 2 : index
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 : index
|
||||
! CHECK-DAG: %[[mem:.*]] = fir.alloca !fir.array<2x!fir.char<1,10>>
|
||||
character(10) :: array(2)
|
||||
array(1) ="(15HThis i"
|
||||
array(2) ="s a test.)"
|
||||
! CHECK-DAG: %[[fmtLen:.*]] = arith.muli %[[c10]], %[[c2]] : index
|
||||
! CHECK-DAG: %[[scalarFmt:.*]] = fir.convert %[[mem]] : (!fir.ref<!fir.array<2x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK-DAG: %[[fmtArg:.*]] = fir.convert %[[scalarFmt]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
|
||||
! CHECK-DAG: %[[fmtLenArg:.*]] = fir.convert %[[fmtLen]] : (index) -> i64
|
||||
! CHECK: fir.call @_FortranAioBeginExternalFormattedOutput(%[[fmtArg]], %[[fmtLenArg]], {{.*}})
|
||||
write(*, array)
|
||||
end subroutine
|
||||
|
||||
! A test to check the buffer and it's length.
|
||||
! CHECK-LABEL: @_QPsome
|
||||
subroutine some()
|
||||
character(LEN=255):: buffer
|
||||
character(LEN=255):: greeting
|
||||
10 format (A255)
|
||||
! CHECK: fir.address_of(@_QQcl.636F6D70696C6572) :
|
||||
write (buffer, 10) "compiler"
|
||||
read (buffer, 10) greeting
|
||||
end
|
||||
! CHECK-LABEL: fir.global linkonce @_QQcl.636F6D70696C6572
|
||||
! CHECK: %[[lit:.*]] = fir.string_lit "compiler"(8) : !fir.char<1,8>
|
||||
! CHECK: fir.has_value %[[lit]] : !fir.char<1,8>
|
||||
! CHECK: }
|
||||
|
|
|
|||
|
|
@ -6,17 +6,17 @@
|
|||
! CHECK-LABEL: func @_QPtest_stmt_0(
|
||||
! CHECK-SAME: %{{.*}}: !fir.ref<f32>{{.*}}) -> f32
|
||||
real function test_stmt_0(x)
|
||||
real :: x, func, arg
|
||||
func(arg) = arg + 0.123456
|
||||
real :: x, func, arg
|
||||
func(arg) = arg + 0.123456
|
||||
|
||||
! CHECK-DAG: %[[x:.*]] = fir.load %arg0
|
||||
! CHECK-DAG: %[[cst:.*]] = arith.constant 1.234560e-01
|
||||
! CHECK: %[[eval:.*]] = arith.addf %[[x]], %[[cst]]
|
||||
! CHECK: fir.store %[[eval]] to %[[resmem:.*]] : !fir.ref<f32>
|
||||
test_stmt_0 = func(x)
|
||||
! CHECK-DAG: %[[x:.*]] = fir.load %arg0
|
||||
! CHECK-DAG: %[[cst:.*]] = arith.constant 1.234560e-01
|
||||
! CHECK: %[[eval:.*]] = arith.addf %[[x]], %[[cst]]
|
||||
! CHECK: fir.store %[[eval]] to %[[resmem:.*]] : !fir.ref<f32>
|
||||
test_stmt_0 = func(x)
|
||||
|
||||
! CHECK: %[[res:.*]] = fir.load %[[resmem]]
|
||||
! CHECK: return %[[res]]
|
||||
! CHECK: %[[res:.*]] = fir.load %[[resmem]]
|
||||
! CHECK: return %[[res]]
|
||||
end function
|
||||
|
||||
! Check this is not lowered as a simple macro: e.g. argument is only
|
||||
|
|
@ -24,51 +24,51 @@ end function
|
|||
! statement function expression
|
||||
! CHECK-LABEL: func @_QPtest_stmt_only_eval_arg_once() -> f32
|
||||
real(4) function test_stmt_only_eval_arg_once()
|
||||
real(4) :: only_once, x1
|
||||
func(x1) = x1 + x1
|
||||
! CHECK: %[[x2:.*]] = fir.alloca f32 {adapt.valuebyref}
|
||||
! CHECK: %[[x1:.*]] = fir.call @_QPonly_once()
|
||||
! Note: using -emit-fir, so the faked pass-by-reference is exposed
|
||||
! CHECK: fir.store %[[x1]] to %[[x2]]
|
||||
! CHECK: addf %{{.*}}, %{{.*}}
|
||||
test_stmt_only_eval_arg_once = func(only_once())
|
||||
real(4) :: only_once, x1
|
||||
func(x1) = x1 + x1
|
||||
! CHECK: %[[x2:.*]] = fir.alloca f32 {adapt.valuebyref}
|
||||
! CHECK: %[[x1:.*]] = fir.call @_QPonly_once()
|
||||
! Note: using -emit-fir, so the faked pass-by-reference is exposed
|
||||
! CHECK: fir.store %[[x1]] to %[[x2]]
|
||||
! CHECK: addf %{{.*}}, %{{.*}}
|
||||
test_stmt_only_eval_arg_once = func(only_once())
|
||||
end function
|
||||
|
||||
! Test nested statement function (note that they cannot be recursively
|
||||
! nested as per F2018 C1577).
|
||||
real function test_stmt_1(x, a)
|
||||
real :: y, a, b, foo
|
||||
real :: func1, arg1, func2, arg2
|
||||
real :: res1, res2
|
||||
func1(arg1) = a + foo(arg1)
|
||||
func2(arg2) = func1(arg2) + b
|
||||
! CHECK-DAG: %[[bmem:.*]] = fir.alloca f32 {{{.*}}uniq_name = "{{.*}}Eb"}
|
||||
! CHECK-DAG: %[[res1:.*]] = fir.alloca f32 {{{.*}}uniq_name = "{{.*}}Eres1"}
|
||||
! CHECK-DAG: %[[res2:.*]] = fir.alloca f32 {{{.*}}uniq_name = "{{.*}}Eres2"}
|
||||
real :: y, a, b, foo
|
||||
real :: func1, arg1, func2, arg2
|
||||
real :: res1, res2
|
||||
func1(arg1) = a + foo(arg1)
|
||||
func2(arg2) = func1(arg2) + b
|
||||
! CHECK-DAG: %[[bmem:.*]] = fir.alloca f32 {{{.*}}uniq_name = "{{.*}}Eb"}
|
||||
! CHECK-DAG: %[[res1:.*]] = fir.alloca f32 {{{.*}}uniq_name = "{{.*}}Eres1"}
|
||||
! CHECK-DAG: %[[res2:.*]] = fir.alloca f32 {{{.*}}uniq_name = "{{.*}}Eres2"}
|
||||
|
||||
b = 5
|
||||
b = 5
|
||||
|
||||
! CHECK-DAG: %[[cst_8:.*]] = arith.constant 8.000000e+00
|
||||
! CHECK-DAG: fir.store %[[cst_8]] to %[[tmp1:.*]] : !fir.ref<f32>
|
||||
! CHECK-DAG: %[[foocall1:.*]] = fir.call @_QPfoo(%[[tmp1]])
|
||||
! CHECK-DAG: %[[aload1:.*]] = fir.load %arg1
|
||||
! CHECK: %[[add1:.*]] = arith.addf %[[aload1]], %[[foocall1]]
|
||||
! CHECK: fir.store %[[add1]] to %[[res1]]
|
||||
res1 = func1(8.)
|
||||
! CHECK-DAG: %[[cst_8:.*]] = arith.constant 8.000000e+00
|
||||
! CHECK-DAG: fir.store %[[cst_8]] to %[[tmp1:.*]] : !fir.ref<f32>
|
||||
! CHECK-DAG: %[[foocall1:.*]] = fir.call @_QPfoo(%[[tmp1]])
|
||||
! CHECK-DAG: %[[aload1:.*]] = fir.load %arg1
|
||||
! CHECK: %[[add1:.*]] = arith.addf %[[aload1]], %[[foocall1]]
|
||||
! CHECK: fir.store %[[add1]] to %[[res1]]
|
||||
res1 = func1(8.)
|
||||
|
||||
! CHECK-DAG: %[[a2:.*]] = fir.load %arg1
|
||||
! CHECK-DAG: %[[foocall2:.*]] = fir.call @_QPfoo(%arg0)
|
||||
! CHECK-DAG: %[[add2:.*]] = arith.addf %[[a2]], %[[foocall2]]
|
||||
! CHECK-DAG: %[[b:.*]] = fir.load %[[bmem]]
|
||||
! CHECK: %[[add3:.*]] = arith.addf %[[add2]], %[[b]]
|
||||
! CHECK: fir.store %[[add3]] to %[[res2]]
|
||||
res2 = func2(x)
|
||||
! CHECK-DAG: %[[a2:.*]] = fir.load %arg1
|
||||
! CHECK-DAG: %[[foocall2:.*]] = fir.call @_QPfoo(%arg0)
|
||||
! CHECK-DAG: %[[add2:.*]] = arith.addf %[[a2]], %[[foocall2]]
|
||||
! CHECK-DAG: %[[b:.*]] = fir.load %[[bmem]]
|
||||
! CHECK: %[[add3:.*]] = arith.addf %[[add2]], %[[b]]
|
||||
! CHECK: fir.store %[[add3]] to %[[res2]]
|
||||
res2 = func2(x)
|
||||
|
||||
! CHECK-DAG: %[[res12:.*]] = fir.load %[[res1]]
|
||||
! CHECK-DAG: %[[res22:.*]] = fir.load %[[res2]]
|
||||
! CHECK: = arith.addf %[[res12]], %[[res22]] : f32
|
||||
test_stmt_1 = res1 + res2
|
||||
! CHECK: return %{{.*}} : f32
|
||||
! CHECK-DAG: %[[res12:.*]] = fir.load %[[res1]]
|
||||
! CHECK-DAG: %[[res22:.*]] = fir.load %[[res2]]
|
||||
! CHECK: = arith.addf %[[res12]], %[[res22]] : f32
|
||||
test_stmt_1 = res1 + res2
|
||||
! CHECK: return %{{.*}} : f32
|
||||
end function
|
||||
|
||||
|
||||
|
|
@ -76,29 +76,29 @@ end function
|
|||
! Test that they are not pre-evaluated.
|
||||
! CHECK-LABEL: func @_QPtest_stmt_no_args
|
||||
real function test_stmt_no_args(x, y)
|
||||
func() = x + y
|
||||
! CHECK: addf
|
||||
a = func()
|
||||
! CHECK: fir.call @_QPfoo_may_modify_xy
|
||||
call foo_may_modify_xy(x, y)
|
||||
! CHECK: addf
|
||||
! CHECK: addf
|
||||
test_stmt_no_args = func() + a
|
||||
func() = x + y
|
||||
! CHECK: addf
|
||||
a = func()
|
||||
! CHECK: fir.call @_QPfoo_may_modify_xy
|
||||
call foo_may_modify_xy(x, y)
|
||||
! CHECK: addf
|
||||
! CHECK: addf
|
||||
test_stmt_no_args = func() + a
|
||||
end function
|
||||
|
||||
! Test statement function with character arguments
|
||||
! CHECK-LABEL: @_QPtest_stmt_character
|
||||
integer function test_stmt_character(c, j)
|
||||
integer :: i, j, func, argj
|
||||
character(10) :: c, argc
|
||||
! CHECK-DAG: %[[unboxed:.*]]:2 = fir.unboxchar %arg0 :
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 :
|
||||
! CHECK: %[[c10_cast:.*]] = fir.convert %[[c10]] : (i32) -> index
|
||||
! CHECK: %[[c:.*]] = fir.emboxchar %[[unboxed]]#0, %[[c10_cast]]
|
||||
integer :: i, j, func, argj
|
||||
character(10) :: c, argc
|
||||
! CHECK-DAG: %[[unboxed:.*]]:2 = fir.unboxchar %arg0 :
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 :
|
||||
! CHECK: %[[c10_cast:.*]] = fir.convert %[[c10]] : (i32) -> index
|
||||
! CHECK: %[[c:.*]] = fir.emboxchar %[[unboxed]]#0, %[[c10_cast]]
|
||||
|
||||
func(argc, argj) = len_trim(argc, 4) + argj
|
||||
! CHECK: addi %{{.*}}, %{{.*}} : i
|
||||
test_stmt_character = func(c, j)
|
||||
func(argc, argj) = len_trim(argc, 4) + argj
|
||||
! CHECK: addi %{{.*}}, %{{.*}} : i
|
||||
test_stmt_character = func(c, j)
|
||||
end function
|
||||
|
||||
! Test statement function with a character actual argument whose
|
||||
|
|
@ -107,41 +107,41 @@ end function
|
|||
! CHECK-LABEL: @_QPtest_stmt_character_with_different_length(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.boxchar<1>
|
||||
integer function test_stmt_character_with_different_length(c)
|
||||
integer :: func, ifoo
|
||||
character(10) :: argc
|
||||
character(*) :: c
|
||||
! CHECK-DAG: %[[unboxed:.*]]:2 = fir.unboxchar %[[arg0]] :
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 :
|
||||
! CHECK: %[[c10_cast:.*]] = fir.convert %[[c10]] : (i32) -> index
|
||||
! CHECK: %[[argc:.*]] = fir.emboxchar %[[unboxed]]#0, %[[c10_cast]]
|
||||
! CHECK: fir.call @_QPifoo(%[[argc]]) : (!fir.boxchar<1>) -> i32
|
||||
func(argc) = ifoo(argc)
|
||||
test_stmt_character = func(c)
|
||||
integer :: func, ifoo
|
||||
character(10) :: argc
|
||||
character(*) :: c
|
||||
! CHECK-DAG: %[[unboxed:.*]]:2 = fir.unboxchar %[[arg0]] :
|
||||
! CHECK-DAG: %[[c10:.*]] = arith.constant 10 :
|
||||
! CHECK: %[[c10_cast:.*]] = fir.convert %[[c10]] : (i32) -> index
|
||||
! CHECK: %[[argc:.*]] = fir.emboxchar %[[unboxed]]#0, %[[c10_cast]]
|
||||
! CHECK: fir.call @_QPifoo(%[[argc]]) : (!fir.boxchar<1>) -> i32
|
||||
func(argc) = ifoo(argc)
|
||||
test_stmt_character = func(c)
|
||||
end function
|
||||
|
||||
! CHECK-LABEL: @_QPtest_stmt_character_with_different_length_2(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.boxchar<1>{{.*}}, %[[arg1:.*]]: !fir.ref<i32>
|
||||
integer function test_stmt_character_with_different_length_2(c, n)
|
||||
integer :: func, ifoo
|
||||
character(n) :: argc
|
||||
character(*) :: c
|
||||
! CHECK: %[[unboxed:.*]]:2 = fir.unboxchar %[[arg0]] :
|
||||
! CHECK: fir.load %[[arg1]] : !fir.ref<i32>
|
||||
! CHECK: %[[n:.*]] = fir.load %[[arg1]] : !fir.ref<i32>
|
||||
! CHECK: %[[n_is_positive:.*]] = arith.cmpi sgt, %[[n]], %c0{{.*}} : i32
|
||||
! CHECK: %[[len:.*]] = arith.select %[[n_is_positive]], %[[n]], %c0{{.*}} : i32
|
||||
! CHECK: %[[lenCast:.*]] = fir.convert %[[len]] : (i32) -> index
|
||||
! CHECK: %[[argc:.*]] = fir.emboxchar %[[unboxed]]#0, %[[lenCast]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPifoo(%[[argc]]) : (!fir.boxchar<1>) -> i32
|
||||
func(argc) = ifoo(argc)
|
||||
test_stmt_character = func(c)
|
||||
integer :: func, ifoo
|
||||
character(n) :: argc
|
||||
character(*) :: c
|
||||
! CHECK: %[[unboxed:.*]]:2 = fir.unboxchar %[[arg0]] :
|
||||
! CHECK: fir.load %[[arg1]] : !fir.ref<i32>
|
||||
! CHECK: %[[n:.*]] = fir.load %[[arg1]] : !fir.ref<i32>
|
||||
! CHECK: %[[n_is_positive:.*]] = arith.cmpi sgt, %[[n]], %c0{{.*}} : i32
|
||||
! CHECK: %[[len:.*]] = arith.select %[[n_is_positive]], %[[n]], %c0{{.*}} : i32
|
||||
! CHECK: %[[lenCast:.*]] = fir.convert %[[len]] : (i32) -> index
|
||||
! CHECK: %[[argc:.*]] = fir.emboxchar %[[unboxed]]#0, %[[lenCast]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPifoo(%[[argc]]) : (!fir.boxchar<1>) -> i32
|
||||
func(argc) = ifoo(argc)
|
||||
test_stmt_character = func(c)
|
||||
end function
|
||||
|
||||
! issue #247
|
||||
! CHECK-LABEL: @_QPbug247
|
||||
subroutine bug247(r)
|
||||
I(R) = R
|
||||
! CHECK: fir.call {{.*}}OutputInteger
|
||||
PRINT *, I(2.5)
|
||||
! CHECK: fir.call {{.*}}EndIo
|
||||
I(R) = R
|
||||
! CHECK: fir.call {{.*}}OutputInteger
|
||||
PRINT *, I(2.5)
|
||||
! CHECK: fir.call {{.*}}EndIo
|
||||
END subroutine bug247
|
||||
|
|
|
|||
|
|
@ -9,281 +9,281 @@
|
|||
|
||||
|
||||
module test2
|
||||
interface
|
||||
subroutine takes_array_desc(l)
|
||||
logical(1) :: l(:)
|
||||
end subroutine
|
||||
end interface
|
||||
|
||||
contains
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_io(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
|
||||
subroutine in_io(x)
|
||||
logical(1) :: x(:, :)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK-DAG: %[[res_arg:.*]] = fir.convert %[[res_desc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK-DAG: %[[x_arg:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim(%[[res_arg]], %[[x_arg]], {{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[io_embox:.*]] = fir.embox %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: %[[io_embox_cast:.*]] = fir.convert %[[io_embox]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_Fortran{{.*}}ioOutputDescriptor({{.*}}, %[[io_embox_cast]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
print *, all(x, 1)
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_call(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
|
||||
subroutine in_call(x)
|
||||
implicit none
|
||||
logical(1) :: x(:, :)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK-DAG: %[[res_arg:.*]] = fir.convert %[[res_desc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK-DAG: %[[x_arg:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim(%[[res_arg]], %[[x_arg]], {{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[call_embox:.*]] = fir.embox %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: fir.call @_QPtakes_array_desc(%[[call_embox]]) : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> ()
|
||||
call takes_array_desc(all(x, 1))
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_implicit_call(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
|
||||
subroutine in_implicit_call(x)
|
||||
logical(1) :: x(:, :)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: %[[res_addr_cast:.*]] = fir.convert %[[res_addr]] : (!fir.heap<!fir.array<?x!fir.logical<1>>>) -> !fir.ref<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: fir.call @_QPtakes_implicit_array(%[[res_addr_cast]]) : (!fir.ref<!fir.array<?x!fir.logical<1>>>) -> ()
|
||||
call takes_implicit_array(all(x, 1))
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_assignment(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}})
|
||||
subroutine in_assignment(x, y)
|
||||
logical(1) :: x(:, :), y(:)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK: %[[y_load:.*]] = fir.array_load %[[arg1]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim
|
||||
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[res_load:.*]] = fir.array_load %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<1>>
|
||||
|
||||
! CHECK: %[[assign:.*]] = fir.do_loop %[[idx:.*]] = %{{.*}} to {{.*}} {
|
||||
! CHECK: %[[res_elt:.*]] = fir.array_fetch %[[res_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
|
||||
! CHECK: fir.array_update %{{.*}} %[[res_elt]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, !fir.logical<1>, index) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[y_load]], %[[assign]] to %[[arg1]] : !fir.array<?x!fir.logical<1>>, !fir.array<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
y = all(x, 1)
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_elem_expr(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}}, %[[arg2:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}})
|
||||
subroutine in_elem_expr(x, y, z)
|
||||
logical(1) :: x(:, :), y(:), z(:)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK-DAG: %[[y_load:.*]] = fir.array_load %[[arg1]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK-DAG: %[[z_load:.*]] = fir.array_load %[[arg2]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim
|
||||
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[res_load:.*]] = fir.array_load %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<1>>
|
||||
|
||||
! CHECK: %[[elem_expr:.*]] = fir.do_loop %[[idx:.*]] = %{{.*}} to {{.*}} {
|
||||
! CHECK-DAG: %[[y_elt:.*]] = fir.array_fetch %[[y_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
|
||||
! CHECK-DAG: %[[res_elt:.*]] = fir.array_fetch %[[res_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
|
||||
! CHECK-DAG: %[[y_elt_i1:.*]] = fir.convert %[[y_elt]] : (!fir.logical<1>) -> i1
|
||||
! CHECK-DAG: %[[res_elt_i1:.*]] = fir.convert %[[res_elt]] : (!fir.logical<1>) -> i1
|
||||
! CHECK: %[[neqv_i1:.*]] = arith.cmpi ne, %[[y_elt_i1]], %[[res_elt_i1]] : i1
|
||||
! CHECK: %[[neqv:.*]] = fir.convert %[[neqv_i1]] : (i1) -> !fir.logical<1>
|
||||
! CHECK: fir.array_update %{{.*}} %[[neqv]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, !fir.logical<1>, index) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[z_load]], %[[elem_expr]] to %[[arg2]] : !fir.array<?x!fir.logical<1>>, !fir.array<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
z = y .neqv. all(x, 1)
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CSHIFT
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pcshift_test() {
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca i32
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_5:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "array", uniq_name = "_QMtest2Fcshift_testEarray"}
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_8:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "result", uniq_name = "_QMtest2Fcshift_testEresult"}
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_10:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "shift", uniq_name = "_QMtest2Fcshift_testEshift"}
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 6 : index
|
||||
! CHECK: %[[VAL_12:.*]] = fir.alloca !fir.array<6xi32> {bindc_name = "vector", uniq_name = "_QMtest2Fcshift_testEvector"}
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 6 : index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.alloca !fir.array<6xi32> {bindc_name = "vectorresult", uniq_name = "_QMtest2Fcshift_testEvectorresult"}
|
||||
! CHECK: %[[VAL_15:.*]] = fir.shape %[[VAL_6]], %[[VAL_7]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_8]](%[[VAL_15]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.array<3x3xi32>
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant -2 : i32
|
||||
! CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_3]], %[[VAL_4]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_5]](%[[VAL_18]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_21]], %[[VAL_21]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.embox %[[VAL_20]](%[[VAL_22]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_23]] to %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.embox %[[VAL_10]](%[[VAL_24]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.address_of(@_QQcl{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_27:.*]] = arith.constant {{[0-9]+}} : i32
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_19]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_25]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,{{[0-9]+}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_32:.*]] = fir.call @_FortranACshift(%[[VAL_28]], %[[VAL_29]], %[[VAL_30]], %[[VAL_17]], %[[VAL_31]], %[[VAL_27]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[VAL_33:.*]] = fir.load %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_35:.*]]:3 = fir.box_dims %[[VAL_33]], %[[VAL_34]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_36:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_37:.*]]:3 = fir.box_dims %[[VAL_33]], %[[VAL_36]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_38:.*]] = fir.box_addr %[[VAL_33]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[VAL_39:.*]] = fir.shape_shift %[[VAL_35]]#0, %[[VAL_35]]#1, %[[VAL_37]]#0, %[[VAL_37]]#1 : (index, index, index, index) -> !fir.shapeshift<2>
|
||||
! CHECK: %[[VAL_40:.*]] = fir.array_load %[[VAL_38]](%[[VAL_39]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shapeshift<2>) -> !fir.array<?x?xi32>
|
||||
! CHECK: %[[VAL_41:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_42:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_6]], %[[VAL_41]] : index
|
||||
! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_7]], %[[VAL_41]] : index
|
||||
! CHECK: %[[VAL_45:.*]] = fir.do_loop %[[VAL_46:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_41]] unordered iter_args(%[[VAL_47:.*]] = %[[VAL_16]]) -> (!fir.array<3x3xi32>) {
|
||||
! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_47]]) -> (!fir.array<3x3xi32>) {
|
||||
! CHECK: %[[VAL_51:.*]] = fir.array_fetch %[[VAL_40]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<?x?xi32>, index, index) -> i32
|
||||
! CHECK: %[[VAL_52:.*]] = fir.array_update %[[VAL_50]], %[[VAL_51]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<3x3xi32>, i32, index, index) -> !fir.array<3x3xi32>
|
||||
! CHECK: fir.result %[[VAL_52]] : !fir.array<3x3xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_53:.*]] : !fir.array<3x3xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_16]], %[[VAL_54:.*]] to %[[VAL_8]] : !fir.array<3x3xi32>, !fir.array<3x3xi32>, !fir.ref<!fir.array<3x3xi32>>
|
||||
! CHECK: fir.freemem %[[VAL_38]]
|
||||
! CHECK: %[[VAL_55:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_56:.*]] = fir.array_load %[[VAL_14]](%[[VAL_55]]) : (!fir.ref<!fir.array<6xi32>>, !fir.shape<1>) -> !fir.array<6xi32>
|
||||
! CHECK: %[[VAL_57:.*]] = arith.constant 3 : i32
|
||||
! CHECK: fir.store %[[VAL_57]] to %[[VAL_1]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_58:.*]] = fir.shape %[[VAL_11]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_59:.*]] = fir.embox %[[VAL_12]](%[[VAL_58]]) : (!fir.ref<!fir.array<6xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<6xi32>>
|
||||
! CHECK: %[[VAL_60:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_61:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_62:.*]] = fir.shape %[[VAL_61]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_63:.*]] = fir.embox %[[VAL_60]](%[[VAL_62]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_63]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[VAL_64:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_65:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_66:.*]] = arith.constant {{[0-9]+}} : i32
|
||||
! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_59]] : (!fir.box<!fir.array<6xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_69:.*]] = fir.convert %[[VAL_64]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_70:.*]] = fir.convert %[[VAL_65]] : (!fir.ref<!fir.char<1,{{[0-9]+}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_71:.*]] = fir.call @_FortranACshiftVector(%[[VAL_67]], %[[VAL_68]], %[[VAL_69]], %[[VAL_70]], %[[VAL_66]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i64, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[VAL_72:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[VAL_73:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_74:.*]]:3 = fir.box_dims %[[VAL_72]], %[[VAL_73]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_75:.*]] = fir.box_addr %[[VAL_72]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_76:.*]] = fir.shape_shift %[[VAL_74]]#0, %[[VAL_74]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_77:.*]] = fir.array_load %[[VAL_75]](%[[VAL_76]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
|
||||
! CHECK: %[[VAL_78:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_79:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_80:.*]] = arith.subi %[[VAL_13]], %[[VAL_78]] : index
|
||||
! CHECK: %[[VAL_81:.*]] = fir.do_loop %[[VAL_82:.*]] = %[[VAL_79]] to %[[VAL_80]] step %[[VAL_78]] unordered iter_args(%[[VAL_83:.*]] = %[[VAL_56]]) -> (!fir.array<6xi32>) {
|
||||
! CHECK: %[[VAL_84:.*]] = fir.array_fetch %[[VAL_77]], %[[VAL_82]] : (!fir.array<?xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_85:.*]] = fir.array_update %[[VAL_83]], %[[VAL_84]], %[[VAL_82]] : (!fir.array<6xi32>, i32, index) -> !fir.array<6xi32>
|
||||
! CHECK: fir.result %[[VAL_85]] : !fir.array<6xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_56]], %[[VAL_86:.*]] to %[[VAL_14]] : !fir.array<6xi32>, !fir.array<6xi32>, !fir.ref<!fir.array<6xi32>>
|
||||
! CHECK: fir.freemem %[[VAL_75]]
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine cshift_test()
|
||||
integer, dimension (3, 3) :: array
|
||||
integer, dimension(3) :: shift
|
||||
integer, dimension(3, 3) :: result
|
||||
integer, dimension(6) :: vectorResult
|
||||
integer, dimension (6) :: vector
|
||||
result = cshift(array, shift, -2) ! non-vector case
|
||||
vectorResult = cshift(vector, 3) ! vector case
|
||||
end subroutine cshift_test
|
||||
|
||||
! UNPACK
|
||||
! CHECK-LABEL: func @_QMtest2Punpack_test
|
||||
subroutine unpack_test()
|
||||
integer, dimension(3) :: vector
|
||||
integer, dimension (3,3) :: field
|
||||
|
||||
logical, dimension(3,3) :: mask
|
||||
integer, dimension(3,3) :: result
|
||||
result = unpack(vector, mask, field)
|
||||
! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-DAG: %[[a1:.*]] = fir.alloca i32
|
||||
! CHECK-DAG: %[[a2:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-DAG: %[[a3:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "field", uniq_name = "_QMtest2Funpack_testEfield"}
|
||||
! CHECK-DAG: %[[a4:.*]] = fir.alloca !fir.array<3x3x!fir.logical<4>> {bindc_name = "mask", uniq_name = "_QMtest2Funpack_testEmask"}
|
||||
! CHECK-DAG: %[[a5:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "result", uniq_name = "_QMtest2Funpack_testEresult"}
|
||||
! CHECK-DAG: %[[a6:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "vector", uniq_name = "_QMtest2Funpack_testEvector"}
|
||||
! CHECK: %[[a7:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK-NEXT: %[[a8:.*]] = fir.array_load %[[a5]](%[[a7]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.array<3x3xi32>
|
||||
! CHECK: %[[a9:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[a10:.*]] = fir.embox %[[a6]](%[[a9]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
|
||||
! CHECK: %[[a11:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a12:.*]] = fir.embox %[[a4]](%[[a11]]) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
|
||||
! CHECK: %[[a13:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK-NEXT: %[[a14:.*]] = fir.embox %[[a3]](%[[a13]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
|
||||
! CHECK: %[[a15:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[a16:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a17:.*]] = fir.embox %[[a15]](%[[a16]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-NEXT: fir.store %[[a17]] to %[[a2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK-DAG: %[[a19:.*]] = fir.convert %[[a2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK-DAG: %[[a20:.*]] = fir.convert %[[a10]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
|
||||
! CHECK-DAG: %[[a21:.*]] = fir.convert %[[a12]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
|
||||
! CHECK-DAG: %[[a22:.*]] = fir.convert %[[a14]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_FortranAUnpack(%[[a19]], %[[a20]], %[[a21]], %[[a22]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
! CHECK-NEXT: %[[a22:.*]] = fir.load %{{.*}} : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[a25:.*]] = fir.box_addr %[[a22]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: fir.freemem %[[a25]]
|
||||
! CHECK: %[[a36:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a38:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK-NEXT: %[[a39:.*]] = fir.embox %[[a6]](%[[a38]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
|
||||
! CHECK: %[[a40:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK-NEXT: %[[a41:.*]] = fir.embox %[[a4]](%[[a40]]) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
|
||||
! CHECK: %[[a42:.*]] = fir.embox %[[a1]] : (!fir.ref<i32>) -> !fir.box<i32>
|
||||
! CHECK: %[[a43:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[a44:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a45:.*]] = fir.embox %[[a43]](%[[a44]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-NEXT: fir.store %[[a45]] to %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[a47:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[a48:.*]] = fir.convert %[[a39]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[a49:.*]] = fir.convert %[[a41]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
|
||||
! CHECK: %[[a50:.*]] = fir.convert %[[a42]] : (!fir.box<i32>) -> !fir.box<none>
|
||||
result = unpack(vector, mask, 343)
|
||||
! CHECK: fir.call @_FortranAUnpack(%[[a47]], %[[a48]], %[[a49]], %[[a50]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[a53:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[a56:.*]] = fir.box_addr %[[a53]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: fir.freemem %[[a56]]
|
||||
! CHECK-NEXT: return
|
||||
end subroutine unpack_test
|
||||
|
||||
end module
|
||||
interface
|
||||
subroutine takes_array_desc(l)
|
||||
logical(1) :: l(:)
|
||||
end subroutine
|
||||
end interface
|
||||
|
||||
contains
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_io(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
|
||||
subroutine in_io(x)
|
||||
logical(1) :: x(:, :)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK-DAG: %[[res_arg:.*]] = fir.convert %[[res_desc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK-DAG: %[[x_arg:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim(%[[res_arg]], %[[x_arg]], {{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[io_embox:.*]] = fir.embox %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: %[[io_embox_cast:.*]] = fir.convert %[[io_embox]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_Fortran{{.*}}ioOutputDescriptor({{.*}}, %[[io_embox_cast]]) : (!fir.ref<i8>, !fir.box<none>) -> i1
|
||||
print *, all(x, 1)
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_call(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
|
||||
subroutine in_call(x)
|
||||
implicit none
|
||||
logical(1) :: x(:, :)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK-DAG: %[[res_arg:.*]] = fir.convert %[[res_desc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK-DAG: %[[x_arg:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim(%[[res_arg]], %[[x_arg]], {{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[call_embox:.*]] = fir.embox %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: fir.call @_QPtakes_array_desc(%[[call_embox]]) : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> ()
|
||||
call takes_array_desc(all(x, 1))
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_implicit_call(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
|
||||
subroutine in_implicit_call(x)
|
||||
logical(1) :: x(:, :)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: %[[res_addr_cast:.*]] = fir.convert %[[res_addr]] : (!fir.heap<!fir.array<?x!fir.logical<1>>>) -> !fir.ref<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK: fir.call @_QPtakes_implicit_array(%[[res_addr_cast]]) : (!fir.ref<!fir.array<?x!fir.logical<1>>>) -> ()
|
||||
call takes_implicit_array(all(x, 1))
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_assignment(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}})
|
||||
subroutine in_assignment(x, y)
|
||||
logical(1) :: x(:, :), y(:)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK: %[[y_load:.*]] = fir.array_load %[[arg1]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim
|
||||
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[res_load:.*]] = fir.array_load %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<1>>
|
||||
|
||||
! CHECK: %[[assign:.*]] = fir.do_loop %[[idx:.*]] = %{{.*}} to {{.*}} {
|
||||
! CHECK: %[[res_elt:.*]] = fir.array_fetch %[[res_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
|
||||
! CHECK: fir.array_update %{{.*}} %[[res_elt]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, !fir.logical<1>, index) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[y_load]], %[[assign]] to %[[arg1]] : !fir.array<?x!fir.logical<1>>, !fir.array<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
y = all(x, 1)
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pin_elem_expr(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}}, %[[arg2:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}})
|
||||
subroutine in_elem_expr(x, y, z)
|
||||
logical(1) :: x(:, :), y(:), z(:)
|
||||
! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
|
||||
! CHECK-DAG: %[[y_load:.*]] = fir.array_load %[[arg1]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK-DAG: %[[z_load:.*]] = fir.array_load %[[arg2]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: fir.call @_Fortran{{.*}}AllDim
|
||||
|
||||
! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
|
||||
! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[res_load:.*]] = fir.array_load %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<1>>
|
||||
|
||||
! CHECK: %[[elem_expr:.*]] = fir.do_loop %[[idx:.*]] = %{{.*}} to {{.*}} {
|
||||
! CHECK-DAG: %[[y_elt:.*]] = fir.array_fetch %[[y_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
|
||||
! CHECK-DAG: %[[res_elt:.*]] = fir.array_fetch %[[res_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
|
||||
! CHECK-DAG: %[[y_elt_i1:.*]] = fir.convert %[[y_elt]] : (!fir.logical<1>) -> i1
|
||||
! CHECK-DAG: %[[res_elt_i1:.*]] = fir.convert %[[res_elt]] : (!fir.logical<1>) -> i1
|
||||
! CHECK: %[[neqv_i1:.*]] = arith.cmpi ne, %[[y_elt_i1]], %[[res_elt_i1]] : i1
|
||||
! CHECK: %[[neqv:.*]] = fir.convert %[[neqv_i1]] : (i1) -> !fir.logical<1>
|
||||
! CHECK: fir.array_update %{{.*}} %[[neqv]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, !fir.logical<1>, index) -> !fir.array<?x!fir.logical<1>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[z_load]], %[[elem_expr]] to %[[arg2]] : !fir.array<?x!fir.logical<1>>, !fir.array<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
|
||||
z = y .neqv. all(x, 1)
|
||||
! CHECK: fir.freemem %[[res_addr]]
|
||||
end subroutine
|
||||
|
||||
! CSHIFT
|
||||
|
||||
! CHECK-LABEL: func @_QMtest2Pcshift_test() {
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca i32
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_5:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "array", uniq_name = "_QMtest2Fcshift_testEarray"}
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_8:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "result", uniq_name = "_QMtest2Fcshift_testEresult"}
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 3 : index
|
||||
! CHECK: %[[VAL_10:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "shift", uniq_name = "_QMtest2Fcshift_testEshift"}
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 6 : index
|
||||
! CHECK: %[[VAL_12:.*]] = fir.alloca !fir.array<6xi32> {bindc_name = "vector", uniq_name = "_QMtest2Fcshift_testEvector"}
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 6 : index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.alloca !fir.array<6xi32> {bindc_name = "vectorresult", uniq_name = "_QMtest2Fcshift_testEvectorresult"}
|
||||
! CHECK: %[[VAL_15:.*]] = fir.shape %[[VAL_6]], %[[VAL_7]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_8]](%[[VAL_15]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.array<3x3xi32>
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant -2 : i32
|
||||
! CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_3]], %[[VAL_4]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_5]](%[[VAL_18]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_21]], %[[VAL_21]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.embox %[[VAL_20]](%[[VAL_22]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_23]] to %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.embox %[[VAL_10]](%[[VAL_24]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.address_of(@_QQcl{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_27:.*]] = arith.constant {{[0-9]+}} : i32
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_19]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_25]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,{{[0-9]+}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_32:.*]] = fir.call @_FortranACshift(%[[VAL_28]], %[[VAL_29]], %[[VAL_30]], %[[VAL_17]], %[[VAL_31]], %[[VAL_27]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[VAL_33:.*]] = fir.load %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_35:.*]]:3 = fir.box_dims %[[VAL_33]], %[[VAL_34]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_36:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_37:.*]]:3 = fir.box_dims %[[VAL_33]], %[[VAL_36]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_38:.*]] = fir.box_addr %[[VAL_33]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[VAL_39:.*]] = fir.shape_shift %[[VAL_35]]#0, %[[VAL_35]]#1, %[[VAL_37]]#0, %[[VAL_37]]#1 : (index, index, index, index) -> !fir.shapeshift<2>
|
||||
! CHECK: %[[VAL_40:.*]] = fir.array_load %[[VAL_38]](%[[VAL_39]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shapeshift<2>) -> !fir.array<?x?xi32>
|
||||
! CHECK: %[[VAL_41:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_42:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_6]], %[[VAL_41]] : index
|
||||
! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_7]], %[[VAL_41]] : index
|
||||
! CHECK: %[[VAL_45:.*]] = fir.do_loop %[[VAL_46:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_41]] unordered iter_args(%[[VAL_47:.*]] = %[[VAL_16]]) -> (!fir.array<3x3xi32>) {
|
||||
! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_47]]) -> (!fir.array<3x3xi32>) {
|
||||
! CHECK: %[[VAL_51:.*]] = fir.array_fetch %[[VAL_40]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<?x?xi32>, index, index) -> i32
|
||||
! CHECK: %[[VAL_52:.*]] = fir.array_update %[[VAL_50]], %[[VAL_51]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<3x3xi32>, i32, index, index) -> !fir.array<3x3xi32>
|
||||
! CHECK: fir.result %[[VAL_52]] : !fir.array<3x3xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.result %[[VAL_53:.*]] : !fir.array<3x3xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_16]], %[[VAL_54:.*]] to %[[VAL_8]] : !fir.array<3x3xi32>, !fir.array<3x3xi32>, !fir.ref<!fir.array<3x3xi32>>
|
||||
! CHECK: fir.freemem %[[VAL_38]]
|
||||
! CHECK: %[[VAL_55:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_56:.*]] = fir.array_load %[[VAL_14]](%[[VAL_55]]) : (!fir.ref<!fir.array<6xi32>>, !fir.shape<1>) -> !fir.array<6xi32>
|
||||
! CHECK: %[[VAL_57:.*]] = arith.constant 3 : i32
|
||||
! CHECK: fir.store %[[VAL_57]] to %[[VAL_1]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_58:.*]] = fir.shape %[[VAL_11]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_59:.*]] = fir.embox %[[VAL_12]](%[[VAL_58]]) : (!fir.ref<!fir.array<6xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<6xi32>>
|
||||
! CHECK: %[[VAL_60:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_61:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_62:.*]] = fir.shape %[[VAL_61]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_63:.*]] = fir.embox %[[VAL_60]](%[[VAL_62]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_63]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[VAL_64:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_65:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,
|
||||
! CHECK: %[[VAL_66:.*]] = arith.constant {{[0-9]+}} : i32
|
||||
! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_59]] : (!fir.box<!fir.array<6xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[VAL_69:.*]] = fir.convert %[[VAL_64]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_70:.*]] = fir.convert %[[VAL_65]] : (!fir.ref<!fir.char<1,{{[0-9]+}}>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_71:.*]] = fir.call @_FortranACshiftVector(%[[VAL_67]], %[[VAL_68]], %[[VAL_69]], %[[VAL_70]], %[[VAL_66]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i64, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[VAL_72:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[VAL_73:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_74:.*]]:3 = fir.box_dims %[[VAL_72]], %[[VAL_73]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_75:.*]] = fir.box_addr %[[VAL_72]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_76:.*]] = fir.shape_shift %[[VAL_74]]#0, %[[VAL_74]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_77:.*]] = fir.array_load %[[VAL_75]](%[[VAL_76]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
|
||||
! CHECK: %[[VAL_78:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_79:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_80:.*]] = arith.subi %[[VAL_13]], %[[VAL_78]] : index
|
||||
! CHECK: %[[VAL_81:.*]] = fir.do_loop %[[VAL_82:.*]] = %[[VAL_79]] to %[[VAL_80]] step %[[VAL_78]] unordered iter_args(%[[VAL_83:.*]] = %[[VAL_56]]) -> (!fir.array<6xi32>) {
|
||||
! CHECK: %[[VAL_84:.*]] = fir.array_fetch %[[VAL_77]], %[[VAL_82]] : (!fir.array<?xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_85:.*]] = fir.array_update %[[VAL_83]], %[[VAL_84]], %[[VAL_82]] : (!fir.array<6xi32>, i32, index) -> !fir.array<6xi32>
|
||||
! CHECK: fir.result %[[VAL_85]] : !fir.array<6xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_56]], %[[VAL_86:.*]] to %[[VAL_14]] : !fir.array<6xi32>, !fir.array<6xi32>, !fir.ref<!fir.array<6xi32>>
|
||||
! CHECK: fir.freemem %[[VAL_75]]
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine cshift_test()
|
||||
integer, dimension (3, 3) :: array
|
||||
integer, dimension(3) :: shift
|
||||
integer, dimension(3, 3) :: result
|
||||
integer, dimension(6) :: vectorResult
|
||||
integer, dimension (6) :: vector
|
||||
result = cshift(array, shift, -2) ! non-vector case
|
||||
vectorResult = cshift(vector, 3) ! vector case
|
||||
end subroutine cshift_test
|
||||
|
||||
! UNPACK
|
||||
! CHECK-LABEL: func @_QMtest2Punpack_test
|
||||
subroutine unpack_test()
|
||||
integer, dimension(3) :: vector
|
||||
integer, dimension (3,3) :: field
|
||||
|
||||
logical, dimension(3,3) :: mask
|
||||
integer, dimension(3,3) :: result
|
||||
result = unpack(vector, mask, field)
|
||||
! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-DAG: %[[a1:.*]] = fir.alloca i32
|
||||
! CHECK-DAG: %[[a2:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-DAG: %[[a3:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "field", uniq_name = "_QMtest2Funpack_testEfield"}
|
||||
! CHECK-DAG: %[[a4:.*]] = fir.alloca !fir.array<3x3x!fir.logical<4>> {bindc_name = "mask", uniq_name = "_QMtest2Funpack_testEmask"}
|
||||
! CHECK-DAG: %[[a5:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "result", uniq_name = "_QMtest2Funpack_testEresult"}
|
||||
! CHECK-DAG: %[[a6:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "vector", uniq_name = "_QMtest2Funpack_testEvector"}
|
||||
! CHECK: %[[a7:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK-NEXT: %[[a8:.*]] = fir.array_load %[[a5]](%[[a7]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.array<3x3xi32>
|
||||
! CHECK: %[[a9:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[a10:.*]] = fir.embox %[[a6]](%[[a9]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
|
||||
! CHECK: %[[a11:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a12:.*]] = fir.embox %[[a4]](%[[a11]]) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
|
||||
! CHECK: %[[a13:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK-NEXT: %[[a14:.*]] = fir.embox %[[a3]](%[[a13]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
|
||||
! CHECK: %[[a15:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[a16:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a17:.*]] = fir.embox %[[a15]](%[[a16]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-NEXT: fir.store %[[a17]] to %[[a2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK-DAG: %[[a19:.*]] = fir.convert %[[a2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK-DAG: %[[a20:.*]] = fir.convert %[[a10]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
|
||||
! CHECK-DAG: %[[a21:.*]] = fir.convert %[[a12]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
|
||||
! CHECK-DAG: %[[a22:.*]] = fir.convert %[[a14]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_FortranAUnpack(%[[a19]], %[[a20]], %[[a21]], %[[a22]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
! CHECK-NEXT: %[[a22:.*]] = fir.load %{{.*}} : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[a25:.*]] = fir.box_addr %[[a22]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: fir.freemem %[[a25]]
|
||||
! CHECK: %[[a36:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a38:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK-NEXT: %[[a39:.*]] = fir.embox %[[a6]](%[[a38]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
|
||||
! CHECK: %[[a40:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK-NEXT: %[[a41:.*]] = fir.embox %[[a4]](%[[a40]]) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
|
||||
! CHECK: %[[a42:.*]] = fir.embox %[[a1]] : (!fir.ref<i32>) -> !fir.box<i32>
|
||||
! CHECK: %[[a43:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: %[[a44:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[a45:.*]] = fir.embox %[[a43]](%[[a44]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
|
||||
! CHECK-NEXT: fir.store %[[a45]] to %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[a47:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[a48:.*]] = fir.convert %[[a39]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
|
||||
! CHECK: %[[a49:.*]] = fir.convert %[[a41]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
|
||||
! CHECK: %[[a50:.*]] = fir.convert %[[a42]] : (!fir.box<i32>) -> !fir.box<none>
|
||||
result = unpack(vector, mask, 343)
|
||||
! CHECK: fir.call @_FortranAUnpack(%[[a47]], %[[a48]], %[[a49]], %[[a50]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
! CHECK: %[[a53:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
|
||||
! CHECK: %[[a56:.*]] = fir.box_addr %[[a53]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
|
||||
! CHECK: fir.freemem %[[a56]]
|
||||
! CHECK-NEXT: return
|
||||
end subroutine unpack_test
|
||||
|
||||
end module
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue