forked from OSchip/llvm-project
[flang][NFC] Add call lowering tests
This patch adds various lowering test for calls. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122306 Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Mats Petersson <mats.petersson@arm.com>
This commit is contained in:
Valentin Clement
parent
ac4c0d6431
commit
e28e1b4b6d
|
|
@ -0,0 +1,82 @@
|
|||
! Test for PassBy::BaseAddressValueAttribute
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
program call_by_value_attr
|
||||
interface
|
||||
subroutine subri(val)
|
||||
integer, value :: val
|
||||
end subroutine subri
|
||||
subroutine subra(val)
|
||||
integer, value, dimension(10) :: val
|
||||
end subroutine subra
|
||||
end interface
|
||||
|
||||
!CHECK-LABEL: func @_QQmain()
|
||||
integer :: v
|
||||
integer, dimension(10) :: a
|
||||
integer, dimension(15) :: b
|
||||
v = 17
|
||||
call subri(v)
|
||||
!CHECK: %[[COPY:.*]] = fir.alloca i32
|
||||
!CHECK: %[[ARRAY_A:.*]] = fir.address_of(@_QFEa)
|
||||
!CHECK: %[[CONST_10_1:.*]] = arith.constant 10 : index
|
||||
!CHECK: %[[ARRAY_B:.*]] = fir.address_of(@_QFEb)
|
||||
!CHECK: %[[CONST_15_1:.*]] = arith.constant 15 : index
|
||||
!CHECK: %[[VALUE:.*]] = fir.alloca i32 {bindc_name = "v", {{.*}}}
|
||||
!CHECK: %[[CONST:.*]] = arith.constant 17
|
||||
!CHECK: fir.store %[[CONST]] to %[[VALUE]]
|
||||
!CHECK: %[[LOAD:.*]] = fir.load %[[VALUE]]
|
||||
!CHECK: fir.store %[[LOAD]] to %[[COPY]]
|
||||
!CHECK: fir.call @_QPsubri(%[[COPY]]) : {{.*}}
|
||||
a = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /)
|
||||
!CHECK: %[[SHAPE_1:.*]] = fir.shape %[[CONST_10_1]]
|
||||
!CHECK: %[[ARRAY_LOAD_1:.*]] = fir.array_load %[[ARRAY_A]](%[[SHAPE_1]]) : {{.*}}
|
||||
!CHECK: %[[ARRAY_INIT_A:.*]] = fir.address_of({{.*}})
|
||||
!CHECK: %[[CONST_10_2:.*]] = arith.constant 10 : index
|
||||
!CHECK: %[[SHAPE_2:.*]] = fir.shape %[[CONST_10_2]]
|
||||
!CHECK: %[[ARRAY_LOAD_2:.*]] = fir.array_load %[[ARRAY_INIT_A]](%[[SHAPE_2]]) : {{.*}}
|
||||
!CHECK: %[[DO_1:.*]] = fir.do_loop {{.*}} {
|
||||
!CHECK: }
|
||||
!CHECK: fir.array_merge_store %[[ARRAY_LOAD_1]], %[[DO_1]] to %[[ARRAY_A]]
|
||||
!CHECK: %[[ARRAY_COPY:.*]] = fir.allocmem !fir.array<10xi32>, %[[CONST_10_1]] {uniq_name = ".copy"}
|
||||
!CHECK: %[[SHAPE_3:.*]] = fir.shape %[[CONST_10_1]]
|
||||
!CHECK: %[[ARRAY_LOAD_3:.*]] = fir.array_load %[[ARRAY_COPY]](%[[SHAPE_3]]) : {{.*}}
|
||||
!CHECK: %[[SHAPE_4:.*]] = fir.shape %[[CONST_10_1]]
|
||||
!CHECK: %[[ARRAY_LOAD_4:.*]] = fir.array_load %[[ARRAY_A]](%[[SHAPE_4]]) : {{.*}}
|
||||
!CHECK: %[[DO_2:.*]] = fir.do_loop {{.*}} {
|
||||
!CHECK: }
|
||||
!CHECK: fir.array_merge_store %[[ARRAY_LOAD_3]], %[[DO_2]] to %[[ARRAY_COPY]]
|
||||
!CHECK: %[[CONVERT:.*]] = fir.convert %[[ARRAY_COPY]] : (!fir.heap<!fir.array<10xi32>>) -> !fir.ref<!fir.array<10xi32>>
|
||||
!CHECK: fir.call @_QPsubra(%[[CONVERT]])
|
||||
call subra(a)
|
||||
b = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 /)
|
||||
!CHECK: %[[SHAPE_5:.*]] = fir.shape %[[CONST_15_1]]
|
||||
!CHECK: %[[ARRAY_LOAD_5:.*]] = fir.array_load %[[ARRAY_B]](%[[SHAPE_5]]) : {{.*}}
|
||||
!CHECK: %[[ARRAY_INIT_B:.*]] = fir.address_of({{.*}})
|
||||
!CHECK: %[[CONST_15_2:.*]] = arith.constant 15 : index
|
||||
!CHECK: %[[SHAPE_6:.*]] = fir.shape %[[CONST_15_2]] : (index) -> !fir.shape<1>
|
||||
!CHECK: %[[ARRAY_LOAD_6:.*]] = fir.array_load %[[ARRAY_INIT_B]](%[[SHAPE_6]]) : (!fir.ref<!fir.array<15xi32>>, !fir.shape<1>) -> !fir.array<15xi32>
|
||||
!CHECK: %[[DO_3:.*]] = fir.do_loop {{.*}} {
|
||||
!CHECK: }
|
||||
!CHECK: fir.array_merge_store %[[ARRAY_LOAD_5]], %[[DO_3]] to %[[ARRAY_B]]
|
||||
!CHECK: %[[CONST_5:.*]] = arith.constant 5 : i64
|
||||
!CHECK: %[[CONV_5:.*]] = fir.convert %[[CONST_5]] : (i64) -> index
|
||||
!CHECK: %[[CONST_1:.*]] = arith.constant 1 : i64
|
||||
!CHECK: %[[CONV_1:.*]] = fir.convert %[[CONST_1]] : (i64) -> index
|
||||
!CHECK: %[[CONST_15_3:.*]] = arith.constant 15 : i64
|
||||
!CHECK: %[[CONV_15:.*]] = fir.convert %[[CONST_15_3]] : (i64) -> index
|
||||
!CHECK: %[[SHAPE_7:.*]] = fir.shape %[[CONST_15_1]] : (index) -> !fir.shape<1>
|
||||
!CHECK: %[[SLICE:.*]] = fir.slice %[[CONV_5]], %[[CONV_15]], %[[CONV_1]] : (index, index, index) -> !fir.slice<1>
|
||||
!CHECK: %[[BOX:.*]] = fir.embox %[[ARRAY_B]](%[[SHAPE_7]]) [%[[SLICE]]] : (!fir.ref<!fir.array<15xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
|
||||
!CHECK: %[[CONST_0:.*]] = arith.constant 0 : index
|
||||
!CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX]], %[[CONST_0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
|
||||
!CHECK: %[[ARRAY_COPY_2:.*]] = fir.allocmem !fir.array<?xi32>, %[[DIMS]]#1 {uniq_name = ".copy"}
|
||||
!CHECK: %[[SHAPE_8:.*]] = fir.shape %[[DIMS]]#1 : (index) -> !fir.shape<1>
|
||||
!CHECK: %[[ARRAY_LOAD_7:.*]] = fir.array_load %[[ARRAY_COPY_2]](%[[SHAPE_8]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.array<?xi32>
|
||||
!CHECK: %[[ARRAY_LOAD_8:.*]] = fir.array_load %[[BOX]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
|
||||
!CHECK: %[[DO_4:.*]] = fir.do_loop {{.*}} {
|
||||
!CHECK: }
|
||||
!CHECK fir.array_merge_store %[[ARRAY_LOAD_7]], %[[DO_4]] to %[[ARRAY_COPY_2]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.heap<!fir.array<?xi32>>
|
||||
!CHECK: %[[CONVERT_B:.*]] = fir.convert %[[ARRAY_COPY_2]] : (!fir.heap<!fir.array<?xi32>>) -> !fir.ref<!fir.array<10xi32>>
|
||||
!CHECK: fir.call @_QPsubra(%[[CONVERT_B]])
|
||||
call subra(b(5:15))
|
||||
end program call_by_value_attr
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
! Test for PassBy::Value
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
program call_by_value
|
||||
interface
|
||||
subroutine omp_set_nested(enable) bind(c)
|
||||
logical, value :: enable
|
||||
end subroutine omp_set_nested
|
||||
end interface
|
||||
|
||||
logical do_nested
|
||||
do_nested = .FALSE.
|
||||
call omp_set_nested(do_nested)
|
||||
end program call_by_value
|
||||
!CHECK-LABEL: func @_QQmain()
|
||||
!CHECK: %[[LOGICAL:.*]] = fir.alloca !fir.logical<4>
|
||||
!CHECK: %false = arith.constant false
|
||||
!CHECK: %[[VALUE:.*]] = fir.convert %false : (i1) -> !fir.logical<4>
|
||||
!CHECK: fir.store %[[VALUE]] to %[[LOGICAL]]
|
||||
!CHECK: %[[LOAD:.*]] = fir.load %[[LOGICAL]]
|
||||
!CHECK: fir.call @omp_set_nested(%[[LOAD]]) : {{.*}}
|
||||
|
|
@ -0,0 +1,315 @@
|
|||
! Test copy-in / copy-out of non-contiguous variable passed as F77 array arguments.
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! Nominal test
|
||||
! CHECK-LABEL: func @_QPtest_assumed_shape_to_array(
|
||||
! CHECK-SAME: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
|
||||
subroutine test_assumed_shape_to_array(x)
|
||||
real :: x(:)
|
||||
! Creating temp
|
||||
! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x:.*]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1 {uniq_name = ".copyinout"}
|
||||
|
||||
! Copy-in
|
||||
! CHECK-DAG: %[[shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
|
||||
! CHECK-DAG: %[[temp_load:.*]] = fir.array_load %[[temp]](%[[shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
|
||||
! CHECK-DAG: %[[x_load:.*]] = fir.array_load %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.array<?xf32>
|
||||
! CHECK: %[[copyin:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[res:.*]] = %[[temp_load]]) -> (!fir.array<?xf32>) {
|
||||
! CHECK: %[[fetch:.*]] = fir.array_fetch %[[x_load]], %[[i]] : (!fir.array<?xf32>, index) -> f32
|
||||
! CHECK: %[[update:.*]] = fir.array_update %[[res]], %[[fetch]], %[[i]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
|
||||
! CHECK: fir.result %[[update]] : !fir.array<?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[temp_load]], %[[copyin:.*]] to %[[temp]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.heap<!fir.array<?xf32>>
|
||||
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: fir.call @_QPbar(%[[cast]]) : (!fir.ref<!fir.array<?xf32>>) -> ()
|
||||
|
||||
! Copy-out
|
||||
|
||||
! CHECK-DAG: %[[x_load:.*]] = fir.array_load %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.array<?xf32>
|
||||
! CHECK-DAG: %[[shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
|
||||
! CHECK-DAG: %[[temp_load:.*]] = fir.array_load %[[temp]](%[[shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
|
||||
! CHECK: %[[copyout:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[res:.*]] = %[[x_load]]) -> (!fir.array<?xf32>) {
|
||||
! CHECK: %[[fetch:.*]] = fir.array_fetch %[[temp_load]], %[[i]] : (!fir.array<?xf32>, index) -> f32
|
||||
! CHECK: %[[update:.*]] = fir.array_update %[[res]], %[[fetch]], %[[i]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
|
||||
! CHECK: fir.result %[[update]] : !fir.array<?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[x_load]], %[[copyout:.*]] to %[[x]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.array<?xf32>>
|
||||
|
||||
! CHECK: fir.freemem %[[temp]]
|
||||
|
||||
call bar(x)
|
||||
end subroutine
|
||||
|
||||
! Test that copy-in/copy-out does not trigger the re-evaluation of
|
||||
! the designator expression.
|
||||
! CHECK-LABEL: func @_QPeval_expr_only_once(
|
||||
! CHECK-SAME: %[[x:.*]]: !fir.ref<!fir.array<200xf32>>{{.*}}) {
|
||||
subroutine eval_expr_only_once(x)
|
||||
integer :: only_once
|
||||
real :: x(200)
|
||||
! CHECK: fir.call @_QPonly_once()
|
||||
! CHECK: %[[x_section:.*]] = fir.embox %[[x]](%{{.*}}) [%{{.*}}] : (!fir.ref<!fir.array<200xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>
|
||||
! CHECK-NOT: fir.call @_QPonly_once()
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[temp]]
|
||||
! CHECK-NOT: fir.call @_QPonly_once()
|
||||
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: fir.call @_QPbar(%[[cast]]) : (!fir.ref<!fir.array<?xf32>>) -> ()
|
||||
call bar(x(1:200:only_once()))
|
||||
|
||||
! CHECK-NOT: fir.call @_QPonly_once()
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[x_section]]
|
||||
! CHECK-NOT: fir.call @_QPonly_once()
|
||||
! CHECK: fir.freemem %[[temp]]
|
||||
end subroutine
|
||||
|
||||
! Test no copy-in/copy-out is generated for contiguous assumed shapes.
|
||||
! CHECK-LABEL: func @_QPtest_contiguous(
|
||||
! CHECK-SAME: %[[x:.*]]: !fir.box<!fir.array<?xf32>>
|
||||
subroutine test_contiguous(x)
|
||||
real, contiguous :: x(:)
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK-NOT: fir.array_merge_store
|
||||
! CHECK: fir.call @_QPbar(%[[addr]]) : (!fir.ref<!fir.array<?xf32>>) -> ()
|
||||
call bar(x)
|
||||
! CHECK-NOT: fir.array_merge_store
|
||||
! CHECK: return
|
||||
end subroutine
|
||||
|
||||
! Test the parenthesis are preventing copy-out.
|
||||
! CHECK: func @_QPtest_parenthesis(
|
||||
! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
|
||||
subroutine test_parenthesis(x)
|
||||
real :: x(:)
|
||||
! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1 {uniq_name = ".array.expr"}
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[temp]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
|
||||
! CHECK: fir.call @_QPbar(%[[cast]]) : (!fir.ref<!fir.array<?xf32>>) -> ()
|
||||
call bar((x))
|
||||
! CHECK-NOT: fir.array_merge_store
|
||||
! CHECK: fir.freemem %[[temp]]
|
||||
! CHECK: return
|
||||
end subroutine
|
||||
|
||||
! Test copy-in in is skipped for intent(out) arguments.
|
||||
! CHECK: func @_QPtest_intent_out(
|
||||
! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
|
||||
subroutine test_intent_out(x)
|
||||
real :: x(:)
|
||||
interface
|
||||
subroutine bar_intent_out(x)
|
||||
real, intent(out) :: x(100)
|
||||
end subroutine
|
||||
end interface
|
||||
! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
|
||||
! CHECK-NOT: fir.array_merge_store
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPbar_intent_out(%[[cast]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
call bar_intent_out(x)
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[x]]
|
||||
! CHECK: fir.freemem %[[temp]]
|
||||
! CHECK: return
|
||||
end subroutine
|
||||
|
||||
! Test copy-out is skipped for intent(out) arguments.
|
||||
! CHECK: func @_QPtest_intent_in(
|
||||
! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
|
||||
subroutine test_intent_in(x)
|
||||
real :: x(:)
|
||||
interface
|
||||
subroutine bar_intent_in(x)
|
||||
real, intent(in) :: x(100)
|
||||
end subroutine
|
||||
end interface
|
||||
! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[temp]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPbar_intent_in(%[[cast]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
call bar_intent_in(x)
|
||||
! CHECK-NOT: fir.array_merge_store
|
||||
! CHECK: fir.freemem %[[temp]]
|
||||
! CHECK: return
|
||||
end subroutine
|
||||
|
||||
! Test copy-in/copy-out is done for intent(inout)
|
||||
! CHECK: func @_QPtest_intent_inout(
|
||||
! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
|
||||
subroutine test_intent_inout(x)
|
||||
real :: x(:)
|
||||
interface
|
||||
subroutine bar_intent_inout(x)
|
||||
real, intent(inout) :: x(100)
|
||||
end subroutine
|
||||
end interface
|
||||
! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
|
||||
! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[temp]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: fir.call @_QPbar_intent_inout(%[[cast]]) : (!fir.ref<!fir.array<100xf32>>) -> ()
|
||||
call bar_intent_inout(x)
|
||||
! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[x]]
|
||||
! CHECK: fir.freemem %[[temp]]
|
||||
! CHECK: return
|
||||
end subroutine
|
||||
|
||||
! Test characters are handled correctly
|
||||
! CHECK-LABEL: func @_QPtest_char(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,10>>>{{.*}}) {
|
||||
subroutine test_char(x)
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_2]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_4:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_3]]#1 {uniq_name = ".copyinout"}
|
||||
! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_3]]#1 : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.array_load %[[VAL_4]](%[[VAL_5]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_8]] : index
|
||||
! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_6]]) -> (!fir.array<?x!fir.char<1,10>>) {
|
||||
! CHECK: %[[VAL_14:.*]] = fir.array_access %[[VAL_7]], %[[VAL_12]] : (!fir.array<?x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.array_access %[[VAL_13]], %[[VAL_12]] : (!fir.array<?x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_16:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_16]] : (index) -> i64
|
||||
! CHECK: %[[VAL_19:.*]] = arith.muli %[[VAL_17]], %[[VAL_18]] : i64
|
||||
! CHECK: %[[VAL_20:.*]] = arith.constant false
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_15]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_14]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_21]], %[[VAL_22]], %[[VAL_19]], %[[VAL_20]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_23:.*]] = fir.array_amend %[[VAL_13]], %[[VAL_15]] : (!fir.array<?x!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: fir.result %[[VAL_23]] : !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_6]], %[[VAL_24:.*]] to %[[VAL_4]] : !fir.array<?x!fir.char<1,10>>, !fir.array<?x!fir.char<1,10>>, !fir.heap<!fir.array<?x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_4]] : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.emboxchar %[[VAL_25]], %[[VAL_1]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char(%[[VAL_26]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: %[[VAL_27:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_29:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_28]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_30:.*]] = fir.shape %[[VAL_3]]#1 : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_load %[[VAL_4]](%[[VAL_30]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_32:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_33:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_34:.*]] = arith.subi %[[VAL_29]]#1, %[[VAL_32]] : index
|
||||
! CHECK: %[[VAL_35:.*]] = fir.do_loop %[[VAL_36:.*]] = %[[VAL_33]] to %[[VAL_34]] step %[[VAL_32]] unordered iter_args(%[[VAL_37:.*]] = %[[VAL_27]]) -> (!fir.array<?x!fir.char<1,10>>) {
|
||||
! CHECK: %[[VAL_38:.*]] = fir.array_access %[[VAL_31]], %[[VAL_36]] : (!fir.array<?x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_39:.*]] = fir.array_access %[[VAL_37]], %[[VAL_36]] : (!fir.array<?x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_40:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_41:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_40]] : (index) -> i64
|
||||
! CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_41]], %[[VAL_42]] : i64
|
||||
! CHECK: %[[VAL_44:.*]] = arith.constant false
|
||||
! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_39]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_38]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_45]], %[[VAL_46]], %[[VAL_43]], %[[VAL_44]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_47:.*]] = fir.array_amend %[[VAL_37]], %[[VAL_39]] : (!fir.array<?x!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: fir.result %[[VAL_47]] : !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_27]], %[[VAL_48:.*]] to %[[VAL_0]] : !fir.array<?x!fir.char<1,10>>, !fir.array<?x!fir.char<1,10>>, !fir.box<!fir.array<?x!fir.char<1,10>>>
|
||||
! CHECK: fir.freemem %[[VAL_4]]
|
||||
|
||||
character(10) :: x(:)
|
||||
call bar_char(x)
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine test_char
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_substring_does_no_trigger_copy_inout
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.boxchar<1>
|
||||
subroutine test_scalar_substring_does_no_trigger_copy_inout(c, i, j)
|
||||
character(*) :: c
|
||||
integer :: i, j
|
||||
! CHECK: %[[unbox:.*]]:2 = fir.unboxchar %[[arg0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[c:.*]] = fir.convert %[[unbox]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[c]], %{{.*}} : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
|
||||
! CHECK: %[[substr:.*]] = fir.convert %[[coor]] : (!fir.ref<!fir.char<1>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[substr]], %{{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char_2(%[[boxchar]]) : (!fir.boxchar<1>) -> ()
|
||||
call bar_char_2(c(i:j))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue871(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFissue871Tt{i:i32}>>>>{{.*}})
|
||||
subroutine issue871(p)
|
||||
! Test passing implicit derived from scalar pointer (no copy-in/out).
|
||||
type t
|
||||
integer :: i
|
||||
end type t
|
||||
type(t), pointer :: p
|
||||
! CHECK: %[[box_load:.*]] = fir.load %[[p]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: fir.call @_QPbar_derived(%[[cast]])
|
||||
call bar_derived(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue871_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFissue871_arrayTt{i:i32}>>>>>
|
||||
subroutine issue871_array(p)
|
||||
! Test passing implicit derived from contiguous pointer (no copy-in/out).
|
||||
type t
|
||||
integer :: i
|
||||
end type t
|
||||
type(t), pointer, contiguous :: p(:)
|
||||
! CHECK: %[[box_load:.*]] = fir.load %[[p]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: fir.call @_QPbar_derived_array(%[[cast]])
|
||||
call bar_derived_array(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPwhole_components()
|
||||
subroutine whole_components()
|
||||
! Test no copy is made for whole components.
|
||||
type t
|
||||
integer :: i(100)
|
||||
end type
|
||||
! CHECK: %[[a:.*]] = fir.alloca !fir.type<_QFwhole_componentsTt{i:!fir.array<100xi32>}>
|
||||
type(t) :: a
|
||||
! CHECK: %[[field:.*]] = fir.field_index i, !fir.type<_QFwhole_componentsTt{i:!fir.array<100xi32>}>
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[a]], %[[field]] : (!fir.ref<!fir.type<_QFwhole_componentsTt{i:!fir.array<100xi32>}>>, !fir.field) -> !fir.ref<!fir.array<100xi32>>
|
||||
! CHECK: fir.call @_QPbar_integer(%[[addr]]) : (!fir.ref<!fir.array<100xi32>>) -> ()
|
||||
call bar_integer(a%i)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPwhole_component_contiguous_pointer()
|
||||
subroutine whole_component_contiguous_pointer()
|
||||
! Test no copy is made for whole contiguous pointer components.
|
||||
type t
|
||||
integer, pointer, contiguous :: i(:)
|
||||
end type
|
||||
! CHECK: %[[a:.*]] = fir.alloca !fir.type<_QFwhole_component_contiguous_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>
|
||||
type(t) :: a
|
||||
! CHECK: %[[field:.*]] = fir.field_index i, !fir.type<_QFwhole_component_contiguous_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a]], %[[field]] : (!fir.ref<!fir.type<_QFwhole_component_contiguous_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[box_load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.ptr<!fir.array<?xi32>>>) -> !fir.ptr<!fir.array<?xi32>>
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.ptr<!fir.array<?xi32>>) -> !fir.ref<!fir.array<100xi32>>
|
||||
! CHECK: fir.call @_QPbar_integer(%[[cast]]) : (!fir.ref<!fir.array<100xi32>>) -> ()
|
||||
call bar_integer(a%i)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPwhole_component_contiguous_char_pointer()
|
||||
subroutine whole_component_contiguous_char_pointer()
|
||||
! Test no copy is made for whole contiguous character pointer components.
|
||||
type t
|
||||
character(:), pointer, contiguous :: i(:)
|
||||
end type
|
||||
! CHECK: %[[a:.*]] = fir.alloca !fir.type<_QFwhole_component_contiguous_char_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>
|
||||
type(t) :: a
|
||||
! CHECK: %[[field:.*]] = fir.field_index i, !fir.type<_QFwhole_component_contiguous_char_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %0, %1 : (!fir.ref<!fir.type<_QFwhole_component_contiguous_char_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[box_load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[len:.*]] = fir.box_elesize %[[box_load]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[embox:.*]] = fir.emboxchar %[[cast]], %[[len]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char_3(%[[embox]]) : (!fir.boxchar<1>) -> ()
|
||||
call bar_char_3(a%i)
|
||||
end subroutine
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
! RUN: bbc %s -o "-" -emit-fir | FileCheck %s
|
||||
! Test lowering of calls to procedures with implicit interfaces using different
|
||||
! calls with different argument types, one of which is character
|
||||
subroutine s2
|
||||
integer i(3)
|
||||
! CHECK: %[[a0:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "i", uniq_name = "_QFs2Ei"}
|
||||
! CHECK: fir.call @_QPsub2(%[[a0]]) : (!fir.ref<!fir.array<3xi32>>) -> ()
|
||||
call sub2(i)
|
||||
! CHECK: %[[a1:.*]] = fir.address_of(@_QQcl.3031323334) : !fir.ref<!fir.char<1,5>>
|
||||
! CHECK: %[[a2:.*]] = fir.convert %[[a1]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[a3:.*]] = fir.convert %[[a2]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<3xi32>>
|
||||
! CHECK: fir.call @_QPsub2(%[[a3]]) : (!fir.ref<!fir.array<3xi32>>) -> ()
|
||||
call sub2("01234")
|
||||
end
|
||||
|
|
@ -0,0 +1,221 @@
|
|||
! Test that temps are always created of parenthesized arguments in
|
||||
! calls.
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo_num_scalar(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32>{{.*}}) {
|
||||
subroutine foo_num_scalar(x)
|
||||
integer :: x
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca i32
|
||||
call bar_num_scalar(x)
|
||||
! CHECK: fir.call @_QPbar_num_scalar(%[[VAL_0]]) : (!fir.ref<i32>) -> ()
|
||||
call bar_num_scalar((x))
|
||||
! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.no_reassoc %[[VAL_2]] : i32
|
||||
! CHECK: fir.store %[[VAL_3]] to %[[VAL_1]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPbar_num_scalar(%[[VAL_1]]) : (!fir.ref<i32>) -> ()
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo_char_scalar(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}) {
|
||||
subroutine foo_char_scalar(x)
|
||||
character(5) :: x
|
||||
! CHECK: %[[VAL_1:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 5 : index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.emboxchar %[[VAL_1]]#0, %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char_scalar(%[[VAL_3]]) : (!fir.boxchar<1>) -> ()
|
||||
call bar_char_scalar(x)
|
||||
! CHECK: %[[VAL_4:.*]] = fir.no_reassoc %[[VAL_1]]#0 : !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.alloca !fir.char<1,5> {bindc_name = ".chrtmp"}
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_2]] : (index) -> i64
|
||||
! CHECK: %[[VAL_8:.*]] = arith.muli %[[VAL_6]], %[[VAL_7]] : i64
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant false
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_4]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_10]], %[[VAL_11]], %[[VAL_8]], %[[VAL_9]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.emboxchar %[[VAL_12]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char_scalar(%[[VAL_13]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
call bar_char_scalar((x))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo_num_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) {
|
||||
subroutine foo_num_array(x)
|
||||
integer :: x(100)
|
||||
call bar_num_array(x)
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 100 : index
|
||||
! CHECK: fir.call @_QPbar_num_array(%[[VAL_0]]) : (!fir.ref<!fir.array<100xi32>>) -> ()
|
||||
call bar_num_array((x))
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.array_load %[[VAL_0]](%[[VAL_4]]) : (!fir.ref<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.array<100xi32>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<100xi32>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_6]](%[[VAL_7]]) : (!fir.heap<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.array<100xi32>
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.subi %[[VAL_3]], %[[VAL_9]] : index
|
||||
! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_8]]) -> (!fir.array<100xi32>) {
|
||||
! CHECK: %[[VAL_15:.*]] = fir.array_fetch %[[VAL_5]], %[[VAL_13]] : (!fir.array<100xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_16:.*]] = fir.no_reassoc %[[VAL_15]] : i32
|
||||
! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_14]], %[[VAL_16]], %[[VAL_13]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32>
|
||||
! CHECK: fir.result %[[VAL_17]] : !fir.array<100xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_8]], %[[VAL_18:.*]] to %[[VAL_6]] : !fir.array<100xi32>, !fir.array<100xi32>, !fir.heap<!fir.array<100xi32>>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_6]] : (!fir.heap<!fir.array<100xi32>>) -> !fir.ref<!fir.array<100xi32>>
|
||||
! CHECK: fir.call @_QPbar_num_array(%[[VAL_19]]) : (!fir.ref<!fir.array<100xi32>>) -> ()
|
||||
! CHECK: fir.freemem %[[VAL_6]]
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo_char_array(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}) {
|
||||
subroutine foo_char_array(x)
|
||||
! CHECK: %[[VAL_1:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_1]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<!fir.array<100x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.emboxchar %[[VAL_5]], %[[VAL_2]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char_array(%[[VAL_6]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_3]](%[[VAL_9]]) : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<100x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.allocmem !fir.array<100x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.array_load %[[VAL_11]](%[[VAL_12]]) : (!fir.heap<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<100x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_8]], %[[VAL_14]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (!fir.array<100x!fir.char<1,10>>) {
|
||||
! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_10]], %[[VAL_18]] : (!fir.array<100x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.no_reassoc %[[VAL_20]] : !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.array_access %[[VAL_19]], %[[VAL_18]] : (!fir.array<100x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_23:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_23]] : (index) -> i64
|
||||
! CHECK: %[[VAL_26:.*]] = arith.muli %[[VAL_24]], %[[VAL_25]] : i64
|
||||
! CHECK: %[[VAL_27:.*]] = arith.constant false
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_21]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_28]], %[[VAL_29]], %[[VAL_26]], %[[VAL_27]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_amend %[[VAL_19]], %[[VAL_22]] : (!fir.array<100x!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) -> !fir.array<100x!fir.char<1,10>>
|
||||
! CHECK: fir.result %[[VAL_30]] : !fir.array<100x!fir.char<1,10>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_13]], %[[VAL_31:.*]] to %[[VAL_11]] : !fir.array<100x!fir.char<1,10>>, !fir.array<100x!fir.char<1,10>>, !fir.heap<!fir.array<100x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_32:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_11]] : (!fir.heap<!fir.array<100x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[VAL_34:.*]] = fir.emboxchar %[[VAL_33]], %[[VAL_32]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPbar_char_array(%[[VAL_34]]) : (!fir.boxchar<1>) -> ()
|
||||
! CHECK: fir.freemem %[[VAL_11]]
|
||||
|
||||
character(10) :: x(100)
|
||||
call bar_char_array(x)
|
||||
call bar_char_array((x))
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo_num_array_box(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) {
|
||||
subroutine foo_num_array_box(x)
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.embox %[[VAL_0]](%[[VAL_2]]) : (!fir.ref<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<100xi32>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.box<!fir.array<100xi32>>) -> !fir.box<!fir.array<?xi32>>
|
||||
! CHECK: fir.call @_QPbar_num_array_box(%[[VAL_4]]) : (!fir.box<!fir.array<?xi32>>) -> ()
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_0]](%[[VAL_7]]) : (!fir.ref<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.array<100xi32>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.allocmem !fir.array<100xi32>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_9]](%[[VAL_10]]) : (!fir.heap<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.array<100xi32>
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_6]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (!fir.array<100xi32>) {
|
||||
! CHECK: %[[VAL_18:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_16]] : (!fir.array<100xi32>, index) -> i32
|
||||
! CHECK: %[[VAL_19:.*]] = fir.no_reassoc %[[VAL_18]] : i32
|
||||
! CHECK: %[[VAL_20:.*]] = fir.array_update %[[VAL_17]], %[[VAL_19]], %[[VAL_16]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32>
|
||||
! CHECK: fir.result %[[VAL_20]] : !fir.array<100xi32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_11]], %[[VAL_21:.*]] to %[[VAL_9]] : !fir.array<100xi32>, !fir.array<100xi32>, !fir.heap<!fir.array<100xi32>>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.embox %[[VAL_9]](%[[VAL_22]]) : (!fir.heap<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<100xi32>>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (!fir.box<!fir.array<100xi32>>) -> !fir.box<!fir.array<?xi32>>
|
||||
! CHECK: fir.call @_QPbar_num_array_box(%[[VAL_24]]) : (!fir.box<!fir.array<?xi32>>) -> ()
|
||||
! CHECK: fir.freemem %[[VAL_9]]
|
||||
|
||||
integer :: x(100)
|
||||
interface
|
||||
subroutine bar_num_array_box(x)
|
||||
integer :: x(:)
|
||||
end subroutine
|
||||
end interface
|
||||
call bar_num_array_box(x)
|
||||
call bar_num_array_box((x))
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPfoo_char_array_box(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.ref<i32>{{.*}}) {
|
||||
subroutine foo_char_array_box(x, n)
|
||||
! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_3]](%[[VAL_7]]) : (!fir.ref<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.call @_QPbar_char_array_box(%[[VAL_9]]) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> ()
|
||||
! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_3]](%[[VAL_10]]) : (!fir.ref<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_6]] {uniq_name = ".array.expr"}
|
||||
! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_14:.*]] = fir.array_load %[[VAL_12]](%[[VAL_13]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_6]], %[[VAL_15]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_14]]) -> (!fir.array<?x!fir.char<1,10>>) {
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_access %[[VAL_11]], %[[VAL_19]] : (!fir.array<?x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.array_access %[[VAL_20]], %[[VAL_19]] : (!fir.array<?x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_24]] : (index) -> i64
|
||||
! CHECK: %[[VAL_27:.*]] = arith.muli %[[VAL_25]], %[[VAL_26]] : i64
|
||||
! CHECK: %[[VAL_28:.*]] = arith.constant false
|
||||
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_23]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_29]], %[[VAL_30]], %[[VAL_27]], %[[VAL_28]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_amend %[[VAL_20]], %[[VAL_23]] : (!fir.array<?x!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) -> !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: fir.result %[[VAL_31]] : !fir.array<?x!fir.char<1,10>>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_14]], %[[VAL_32:.*]] to %[[VAL_12]] : !fir.array<?x!fir.char<1,10>>, !fir.array<?x!fir.char<1,10>>, !fir.heap<!fir.array<?x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_33:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_34:.*]] = fir.embox %[[VAL_12]](%[[VAL_33]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_34]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: fir.call @_QPbar_char_array_box(%[[VAL_35]]) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> ()
|
||||
! CHECK: fir.freemem %[[VAL_12]]
|
||||
|
||||
integer :: n
|
||||
character(10) :: x(n)
|
||||
interface
|
||||
subroutine bar_char_array_box(x)
|
||||
character(*) :: x(:)
|
||||
end subroutine
|
||||
end interface
|
||||
call bar_char_array_box(x)
|
||||
call bar_char_array_box((x))
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
! RUN: bbc %s -o "-" -emit-fir | FileCheck %s
|
||||
|
||||
subroutine sub()
|
||||
real :: x
|
||||
! CHECK: fir.call @_QPasubroutine()
|
||||
call AsUbRoUtInE();
|
||||
! CHECK: fir.call @_QPfoo()
|
||||
x = foo()
|
||||
end subroutine
|
||||
|
||||
module testMod
|
||||
contains
|
||||
subroutine sub()
|
||||
end subroutine
|
||||
|
||||
function foo()
|
||||
end function
|
||||
end module
|
||||
|
||||
subroutine sub1()
|
||||
use testMod
|
||||
real :: x
|
||||
! CHECK: fir.call @_QMtestmodPsub()
|
||||
call Sub();
|
||||
! CHECK: fir.call @_QMtestmodPfoo()
|
||||
x = foo()
|
||||
end subroutine
|
||||
|
||||
subroutine sub2()
|
||||
use testMod, localfoo => foo, localsub => sub
|
||||
real :: x
|
||||
! CHECK: fir.call @_QMtestmodPsub()
|
||||
call localsub();
|
||||
! CHECK: fir.call @_QMtestmodPfoo()
|
||||
x = localfoo()
|
||||
end subroutine
|
||||
|
||||
|
||||
|
||||
subroutine sub3()
|
||||
real :: x
|
||||
! CHECK: fir.call @_QFsub3Psub()
|
||||
call sub();
|
||||
! CHECK: fir.call @_QFsub3Pfoo()
|
||||
x = foo()
|
||||
contains
|
||||
subroutine sub()
|
||||
end subroutine
|
||||
|
||||
function foo()
|
||||
end function
|
||||
end subroutine
|
||||
|
||||
function foo1()
|
||||
real :: bar1
|
||||
! CHECK: fir.call @_QPbar1()
|
||||
foo1 = bar1()
|
||||
end function
|
||||
|
||||
function foo2()
|
||||
! CHECK: fir.call @_QPbar2()
|
||||
foo2 = bar2()
|
||||
end function
|
||||
|
||||
function foo3()
|
||||
interface
|
||||
real function bar3()
|
||||
end function
|
||||
end interface
|
||||
! CHECK: fir.call @_QPbar3()
|
||||
foo3 = bar3()
|
||||
end function
|
||||
|
||||
function foo4()
|
||||
external :: bar4
|
||||
! CHECK: fir.call @_QPbar4()
|
||||
foo4 = bar4()
|
||||
end function
|
||||
|
||||
module test_bindmodule
|
||||
contains
|
||||
! CHECK: func @modulecproc()
|
||||
! CHECK: func @bind_modulecproc()
|
||||
subroutine modulecproc() bind(c)
|
||||
end subroutine
|
||||
subroutine modulecproc_1() bind(c, name="bind_modulecproc")
|
||||
end subroutine
|
||||
end module
|
||||
! CHECK-LABEL: func @_QPtest_bindmodule_call() {
|
||||
subroutine test_bindmodule_call
|
||||
use test_bindmodule
|
||||
interface
|
||||
subroutine somecproc() bind(c)
|
||||
end subroutine
|
||||
subroutine somecproc_1() bind(c, name="bind_somecproc")
|
||||
end subroutine
|
||||
end interface
|
||||
! CHECK: fir.call @modulecproc()
|
||||
! CHECK: fir.call @bind_modulecproc()
|
||||
! CHECK: fir.call @somecproc()
|
||||
! CHECK: fir.call @bind_somecproc()
|
||||
call modulecproc()
|
||||
call modulecproc_1()
|
||||
call somecproc()
|
||||
call somecproc_1()
|
||||
end subroutine
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
! Note: flang will issue warnings for the following subroutines. These
|
||||
! are accepted regardless to maintain backwards compatibility with
|
||||
! other Fortran implementations.
|
||||
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! CHECK-LABEL: func @_QPs1() {
|
||||
! CHECK: %[[cast:.*]] = fir.convert %{{.*}} : (!fir.ref<f32>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[undef:.*]] = fir.undefined index
|
||||
! CHECK: %[[box:.*]] = fir.emboxchar %[[cast]], %[[undef]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPs3(%[[box]]) : (!fir.boxchar<1>) -> ()
|
||||
|
||||
! Pass a REAL by reference to a subroutine expecting a CHARACTER
|
||||
subroutine s1
|
||||
call s3(r)
|
||||
end subroutine s1
|
||||
|
||||
! CHECK-LABEL: func @_QPs2(
|
||||
! CHECK: %[[ptr:.*]] = fir.box_addr %{{.*}} : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[ptr]] : (!fir.ptr<f32>) -> !fir.ref<!fir.char<1,?>>
|
||||
! CHECK: %[[undef:.*]] = fir.undefined index
|
||||
! CHECK: %[[box:.*]] = fir.emboxchar %[[cast]], %[[undef]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
|
||||
! CHECK: fir.call @_QPs3(%[[box]]) : (!fir.boxchar<1>) -> ()
|
||||
|
||||
! Pass a REAL, POINTER data reference to a subroutine expecting a CHARACTER
|
||||
subroutine s2(p)
|
||||
real, pointer :: p
|
||||
call s3(p)
|
||||
end subroutine s2
|
||||
|
||||
! CHECK-LABEL: func @_QPs3(
|
||||
! CHECK-SAME: !fir.boxchar<1>
|
||||
subroutine s3(c)
|
||||
character(8) c
|
||||
end subroutine s3
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
! Test various aspects around call lowering. More detailed tests around core
|
||||
! requirements are done in call-xxx.f90 and dummy-argument-xxx.f90 files.
|
||||
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_nested_calls
|
||||
subroutine test_nested_calls()
|
||||
interface
|
||||
subroutine foo(i)
|
||||
integer :: i
|
||||
end subroutine
|
||||
integer function bar()
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[result_storage:.*]] = fir.alloca i32 {adapt.valuebyref}
|
||||
! CHECK: %[[result:.*]] = fir.call @_QPbar() : () -> i32
|
||||
! CHECK: fir.store %[[result]] to %[[result_storage]] : !fir.ref<i32>
|
||||
! CHECK: fir.call @_QPfoo(%[[result_storage]]) : (!fir.ref<i32>) -> ()
|
||||
call foo(bar())
|
||||
end subroutine
|
||||
Loading…
Reference in New Issue