forked from OSchip/llvm-project
[flang][NFC] Add derived type lowering tests
Add more use cases of lowering of derived types. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122329 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Peter Steinfeld <psteinfeld@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
This commit is contained in:
Valentin Clement
parent
0ca8ff4da1
commit
e847374e19
|
|
@ -0,0 +1,560 @@
|
|||
! Test lowering of allocatable components
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
module acomp
|
||||
implicit none
|
||||
type t
|
||||
real :: x
|
||||
integer :: i
|
||||
end type
|
||||
interface
|
||||
subroutine takes_real_scalar(x)
|
||||
real :: x
|
||||
end subroutine
|
||||
subroutine takes_char_scalar(x)
|
||||
character(*) :: x
|
||||
end subroutine
|
||||
subroutine takes_derived_scalar(x)
|
||||
import t
|
||||
type(t) :: x
|
||||
end subroutine
|
||||
subroutine takes_real_array(x)
|
||||
real :: x(:)
|
||||
end subroutine
|
||||
subroutine takes_char_array(x)
|
||||
character(*) :: x(:)
|
||||
end subroutine
|
||||
subroutine takes_derived_array(x)
|
||||
import t
|
||||
type(t) :: x(:)
|
||||
end subroutine
|
||||
subroutine takes_real_scalar_pointer(x)
|
||||
real, allocatable :: x
|
||||
end subroutine
|
||||
subroutine takes_real_array_pointer(x)
|
||||
real, allocatable :: x(:)
|
||||
end subroutine
|
||||
subroutine takes_logical(x)
|
||||
logical :: x
|
||||
end subroutine
|
||||
end interface
|
||||
|
||||
type real_a0
|
||||
real, allocatable :: p
|
||||
end type
|
||||
type real_a1
|
||||
real, allocatable :: p(:)
|
||||
end type
|
||||
type cst_char_a0
|
||||
character(10), allocatable :: p
|
||||
end type
|
||||
type cst_char_a1
|
||||
character(10), allocatable :: p(:)
|
||||
end type
|
||||
type def_char_a0
|
||||
character(:), allocatable :: p
|
||||
end type
|
||||
type def_char_a1
|
||||
character(:), allocatable :: p(:)
|
||||
end type
|
||||
type derived_a0
|
||||
type(t), allocatable :: p
|
||||
end type
|
||||
type derived_a1
|
||||
type(t), allocatable :: p(:)
|
||||
end type
|
||||
|
||||
real, target :: real_target, real_array_target(100)
|
||||
character(10), target :: char_target, char_array_target(100)
|
||||
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test allocatable component references
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPref_scalar_real_a(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>{{.*}}, %[[arg2:.*]]: !fir.ref<!fir.array<100x!fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>>>{{.*}}, %[[arg3:.*]]: !fir.ref<!fir.array<100x!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>>{{.*}}) {
|
||||
subroutine ref_scalar_real_a(a0_0, a1_0, a0_1, a1_1)
|
||||
type(real_a0) :: a0_0, a0_1(100)
|
||||
type(real_a1) :: a1_0, a1_1(100)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p, !fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[arg0]], %[[fld]] : (!fir.ref<!fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<f32>>>
|
||||
! CHECK: %[[load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.heap<f32>>>
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[load]] : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<f32>) -> !fir.ref<f32>
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[cast]]) : (!fir.ref<f32>) -> ()
|
||||
call takes_real_scalar(a0_0%p)
|
||||
|
||||
! CHECK: %[[a0_1_coor:.*]] = fir.coordinate_of %[[arg2]], %{{.*}} : (!fir.ref<!fir.array<100x!fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>>>, i64) -> !fir.ref<!fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>>
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p, !fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_1_coor]], %[[fld]] : (!fir.ref<!fir.type<_QMacompTreal_a0{p:!fir.box<!fir.heap<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<f32>>>
|
||||
! CHECK: %[[load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.heap<f32>>>
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[load]] : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<f32>) -> !fir.ref<f32>
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[cast]]) : (!fir.ref<f32>) -> ()
|
||||
call takes_real_scalar(a0_1(5)%p)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p, !fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[arg1]], %[[fld]] : (!fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[lb:.*]] = fir.convert %[[dims]]#0 : (index) -> i64
|
||||
! CHECK: %[[index:.*]] = arith.subi %c7{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[addr]], %[[index]] : (!fir.heap<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[coor]]) : (!fir.ref<f32>) -> ()
|
||||
call takes_real_scalar(a1_0%p(7))
|
||||
|
||||
! CHECK: %[[a1_1_coor:.*]] = fir.coordinate_of %[[arg3]], %{{.*}} : (!fir.ref<!fir.array<100x!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>>, i64) -> !fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p, !fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_1_coor]], %[[fld]] : (!fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[lb:.*]] = fir.convert %[[dims]]#0 : (index) -> i64
|
||||
! CHECK: %[[index:.*]] = arith.subi %c7{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[addr]], %[[index]] : (!fir.heap<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[coor]]) : (!fir.ref<f32>) -> ()
|
||||
call takes_real_scalar(a1_1(5)%p(7))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPref_array_real_a(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<100x!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>>{{.*}}) {
|
||||
! CHECK: %[[VAL_2:.*]] = fir.field_index p, !fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_3]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_4]], %[[VAL_5]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_4]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 20 : i64
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i64) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i64) -> index
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 50 : i64
|
||||
! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.shape_shift %[[VAL_6]]#0, %[[VAL_6]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.slice %[[VAL_9]], %[[VAL_13]], %[[VAL_11]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.embox %[[VAL_7]](%[[VAL_14]]) {{\[}}%[[VAL_15]]] : (!fir.heap<!fir.array<?xf32>>, !fir.shapeshift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: fir.call @_QPtakes_real_array(%[[VAL_16]]) : (!fir.box<!fir.array<?xf32>>) -> ()
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant 5 : i64
|
||||
! CHECK: %[[VAL_18:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_17]], %[[VAL_18]] : i64
|
||||
! CHECK: %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_19]] : (!fir.ref<!fir.array<100x!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>>, i64) -> !fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.field_index p, !fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.coordinate_of %[[VAL_20]], %[[VAL_21]] : (!fir.ref<!fir.type<_QMacompTreal_a1{p:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.load %[[VAL_22]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_25:.*]]:3 = fir.box_dims %[[VAL_23]], %[[VAL_24]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_26:.*]] = fir.box_addr %[[VAL_23]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_27:.*]] = arith.constant 20 : i64
|
||||
! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_27]] : (i64) -> index
|
||||
! CHECK: %[[VAL_29:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i64) -> index
|
||||
! CHECK: %[[VAL_31:.*]] = arith.constant 50 : i64
|
||||
! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i64) -> index
|
||||
! CHECK: %[[VAL_33:.*]] = fir.shape_shift %[[VAL_25]]#0, %[[VAL_25]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_34:.*]] = fir.slice %[[VAL_28]], %[[VAL_32]], %[[VAL_30]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_35:.*]] = fir.embox %[[VAL_26]](%[[VAL_33]]) {{\[}}%[[VAL_34]]] : (!fir.heap<!fir.array<?xf32>>, !fir.shapeshift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: fir.call @_QPtakes_real_array(%[[VAL_35]]) : (!fir.box<!fir.array<?xf32>>) -> ()
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine ref_array_real_a(a1_0, a1_1)
|
||||
type(real_a1) :: a1_0, a1_1(100)
|
||||
call takes_real_array(a1_0%p(20:50:2))
|
||||
call takes_real_array(a1_1(5)%p(20:50:2))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPref_scalar_cst_char_a
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine ref_scalar_cst_char_a(a0_0, a1_0, a0_1, a1_1)
|
||||
type(cst_char_a0) :: a0_0, a0_1(100)
|
||||
type(cst_char_a1) :: a1_0, a1_1(100)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cast]], %c10{{.*}}
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cast]], %c10{{.*}}
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a0_1(5)%p)
|
||||
|
||||
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK-DAG: %[[base:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}}
|
||||
! CHECK: %[[lb:.*]] = fir.convert %[[dims]]#0 : (index) -> i64
|
||||
! CHECK: %[[index:.*]] = arith.subi %c7{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[base]], %[[index]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cast]], %c10{{.*}}
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a1_0%p(7))
|
||||
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK-DAG: %[[base:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}}
|
||||
! CHECK: %[[lb:.*]] = fir.convert %[[dims]]#0 : (index) -> i64
|
||||
! CHECK: %[[index:.*]] = arith.subi %c7{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[base]], %[[index]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cast]], %c10{{.*}}
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a1_1(5)%p(7))
|
||||
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPref_scalar_def_char_a
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine ref_scalar_def_char_a(a0_0, a1_0, a0_1, a1_1)
|
||||
type(def_char_a0) :: a0_0, a0_1(100)
|
||||
type(def_char_a1) :: a1_0, a1_1(100)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK-DAG: %[[len:.*]] = fir.box_elesize %[[box]]
|
||||
! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK-DAG: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cast]], %[[len]]
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK-DAG: %[[len:.*]] = fir.box_elesize %[[box]]
|
||||
! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK-DAG: %[[cast:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cast]], %[[len]]
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a0_1(5)%p)
|
||||
|
||||
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}}
|
||||
! CHECK-DAG: %[[len:.*]] = fir.box_elesize %[[box]]
|
||||
! CHECK-DAG: %[[base:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[base]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[c7:.*]] = fir.convert %c7{{.*}} : (i64) -> index
|
||||
! CHECK: %[[sub:.*]] = arith.subi %[[c7]], %[[dims]]#0 : index
|
||||
! CHECK: %[[mul:.*]] = arith.muli %[[len]], %[[sub]] : index
|
||||
! CHECK: %[[offset:.*]] = arith.addi %[[mul]], %c0{{.*}} : index
|
||||
! CHECK: %[[cnvt:.*]] = fir.convert %[[cast]]
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[cnvt]], %[[offset]]
|
||||
! CHECK: %[[cnvt:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cnvt]], %[[len]]
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a1_0%p(7))
|
||||
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}}
|
||||
! CHECK-DAG: %[[len:.*]] = fir.box_elesize %[[box]]
|
||||
! CHECK-DAG: %[[base:.*]] = fir.box_addr %[[box]]
|
||||
! CHECK: %[[cast:.*]] = fir.convert %[[base]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[c7:.*]] = fir.convert %c7{{.*}} : (i64) -> index
|
||||
! CHECK: %[[sub:.*]] = arith.subi %[[c7]], %[[dims]]#0 : index
|
||||
! CHECK: %[[mul:.*]] = arith.muli %[[len]], %[[sub]] : index
|
||||
! CHECK: %[[offset:.*]] = arith.addi %[[mul]], %c0{{.*}} : index
|
||||
! CHECK: %[[cnvt:.*]] = fir.convert %[[cast]]
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[cnvt]], %[[offset]]
|
||||
! CHECK: %[[cnvt:.*]] = fir.convert %[[addr]]
|
||||
! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[cnvt]], %[[len]]
|
||||
! CHECK: fir.call @_QPtakes_char_scalar(%[[boxchar]])
|
||||
call takes_char_scalar(a1_1(5)%p(7))
|
||||
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPref_scalar_derived
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine ref_scalar_derived(a0_0, a1_0, a0_1, a1_1)
|
||||
type(derived_a0) :: a0_0, a0_1(100)
|
||||
type(derived_a1) :: a1_0, a1_1(100)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: %[[fldx:.*]] = fir.field_index x
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[box]], %[[fldx]]
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[addr]])
|
||||
call takes_real_scalar(a0_0%p%x)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: %[[fldx:.*]] = fir.field_index x
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[box]], %[[fldx]]
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[addr]])
|
||||
call takes_real_scalar(a0_1(5)%p%x)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}}
|
||||
! CHECK: %[[lb:.*]] = fir.convert %[[dims]]#0 : (index) -> i64
|
||||
! CHECK: %[[index:.*]] = arith.subi %c7{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[elem:.*]] = fir.coordinate_of %[[box]], %[[index]]
|
||||
! CHECK: %[[fldx:.*]] = fir.field_index x
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[elem]], %[[fldx]]
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[addr]])
|
||||
call takes_real_scalar(a1_0%p(7)%x)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: %[[dims:.*]]:3 = fir.box_dims %[[box]], %c0{{.*}}
|
||||
! CHECK: %[[lb:.*]] = fir.convert %[[dims]]#0 : (index) -> i64
|
||||
! CHECK: %[[index:.*]] = arith.subi %c7{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[elem:.*]] = fir.coordinate_of %[[box]], %[[index]]
|
||||
! CHECK: %[[fldx:.*]] = fir.field_index x
|
||||
! CHECK: %[[addr:.*]] = fir.coordinate_of %[[elem]], %[[fldx]]
|
||||
! CHECK: fir.call @_QPtakes_real_scalar(%[[addr]])
|
||||
call takes_real_scalar(a1_1(5)%p(7)%x)
|
||||
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing allocatable component references as allocatables
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPpass_real_a
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine pass_real_a(a0_0, a1_0, a0_1, a1_1)
|
||||
type(real_a0) :: a0_0, a0_1(100)
|
||||
type(real_a1) :: a1_0, a1_1(100)
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: fir.call @_QPtakes_real_scalar_pointer(%[[coor]])
|
||||
call takes_real_scalar_pointer(a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.call @_QPtakes_real_scalar_pointer(%[[coor]])
|
||||
call takes_real_scalar_pointer(a0_1(5)%p)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: fir.call @_QPtakes_real_array_pointer(%[[coor]])
|
||||
call takes_real_array_pointer(a1_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.call @_QPtakes_real_array_pointer(%[[coor]])
|
||||
call takes_real_array_pointer(a1_1(5)%p)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test usage in intrinsics where pointer aspect matters
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPallocated_p
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine allocated_p(a0_0, a1_0, a0_1, a1_1)
|
||||
type(real_a0) :: a0_0, a0_1(100)
|
||||
type(def_char_a1) :: a1_0, a1_1(100)
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: fir.box_addr %[[box]]
|
||||
call takes_logical(allocated(a0_0%p))
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: fir.box_addr %[[box]]
|
||||
call takes_logical(allocated(a0_1(5)%p))
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: fir.box_addr %[[box]]
|
||||
call takes_logical(allocated(a1_0%p))
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: %[[box:.*]] = fir.load %[[coor]]
|
||||
! CHECK: fir.box_addr %[[box]]
|
||||
call takes_logical(allocated(a1_1(5)%p))
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test allocation
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPallocate_real
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine allocate_real(a0_0, a1_0, a0_1, a1_1)
|
||||
type(real_a0) :: a0_0, a0_1(100)
|
||||
type(real_a1) :: a1_0, a1_1(100)
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a0_1(5)%p)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a1_0%p(100))
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a1_1(5)%p(100))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPallocate_cst_char
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine allocate_cst_char(a0_0, a1_0, a0_1, a1_1)
|
||||
type(cst_char_a0) :: a0_0, a0_1(100)
|
||||
type(cst_char_a1) :: a1_0, a1_1(100)
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a0_1(5)%p)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a1_0%p(100))
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(a1_1(5)%p(100))
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPallocate_def_char
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine allocate_def_char(a0_0, a1_0, a0_1, a1_1)
|
||||
type(def_char_a0) :: a0_0, a0_1(100)
|
||||
type(def_char_a1) :: a1_0, a1_1(100)
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(character(18)::a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(character(18)::a0_1(5)%p)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(character(18)::a1_0%p(100))
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
allocate(character(18)::a1_1(5)%p(100))
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test deallocation
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMacompPdeallocate_real
|
||||
! CHECK-SAME: (%[[a0_0:.*]]: {{.*}}, %[[a1_0:.*]]: {{.*}}, %[[a0_1:.*]]: {{.*}}, %[[a1_1:.*]]: {{.*}})
|
||||
subroutine deallocate_real(a0_0, a1_0, a0_1, a1_1)
|
||||
type(real_a0) :: a0_0, a0_1(100)
|
||||
type(real_a1) :: a1_0, a1_1(100)
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a0_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
deallocate(a0_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a0_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
deallocate(a0_1(5)%p)
|
||||
|
||||
! CHECK: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a1_0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
deallocate(a1_0%p)
|
||||
|
||||
! CHECK-DAG: %[[coor0:.*]] = fir.coordinate_of %[[a1_1]], %{{.*}}
|
||||
! CHECK-DAG: %[[fld:.*]] = fir.field_index p
|
||||
! CHECK: %[[coor:.*]] = fir.coordinate_of %[[coor0]], %[[fld]]
|
||||
! CHECK: fir.store {{.*}} to %[[coor]]
|
||||
deallocate(a1_1(5)%p)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test a recursive derived type reference
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK: func @_QMacompPtest_recursive
|
||||
! CHECK-SAME: (%[[x:.*]]: {{.*}})
|
||||
subroutine test_recursive(x)
|
||||
type t
|
||||
integer :: i
|
||||
type(t), allocatable :: next
|
||||
end type
|
||||
type(t) :: x
|
||||
|
||||
! CHECK: %[[fldNext1:.*]] = fir.field_index next
|
||||
! CHECK: %[[next1:.*]] = fir.coordinate_of %[[x]], %[[fldNext1]]
|
||||
! CHECK: %[[nextBox1:.*]] = fir.load %[[next1]]
|
||||
! CHECK: %[[fldNext2:.*]] = fir.field_index next
|
||||
! CHECK: %[[next2:.*]] = fir.coordinate_of %[[nextBox1]], %[[fldNext2]]
|
||||
! CHECK: %[[nextBox2:.*]] = fir.load %[[next2]]
|
||||
! CHECK: %[[fldNext3:.*]] = fir.field_index next
|
||||
! CHECK: %[[next3:.*]] = fir.coordinate_of %[[nextBox2]], %[[fldNext3]]
|
||||
! CHECK: %[[nextBox3:.*]] = fir.load %[[next3]]
|
||||
! CHECK: %[[fldi:.*]] = fir.field_index i
|
||||
! CHECK: %[[i:.*]] = fir.coordinate_of %[[nextBox3]], %[[fldi]]
|
||||
! CHECK: %[[nextBox3:.*]] = fir.load %[[i]] : !fir.ref<i32>
|
||||
print *, x%next%next%next%i
|
||||
end subroutine
|
||||
|
||||
end module
|
||||
|
|
@ -0,0 +1,228 @@
|
|||
! Test lowering of derived type assignments
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! Assignment of simple "struct" with trivial intrinsic members.
|
||||
! CHECK-LABEL: func @_QPtest1
|
||||
subroutine test1
|
||||
type t
|
||||
integer a
|
||||
integer b
|
||||
end type t
|
||||
type(t) :: t1, t2
|
||||
! CHECK-DAG: %[[VAL_0:.*]] = fir.alloca !fir.type<_QFtest1Tt{a:i32,b:i32}> {{{.*}}uniq_name = "_QFtest1Et1"}
|
||||
! CHECK-DAG: %[[VAL_1:.*]] = fir.alloca !fir.type<_QFtest1Tt{a:i32,b:i32}> {{{.*}}uniq_name = "_QFtest1Et2"}
|
||||
! CHECK: %[[VAL_2:.*]] = fir.field_index a, !fir.type<_QFtest1Tt{a:i32,b:i32}>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest1Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest1Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL_5]] to %[[VAL_4]] : !fir.ref<i32>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.field_index b, !fir.type<_QFtest1Tt{a:i32,b:i32}>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_6]] : (!fir.ref<!fir.type<_QFtest1Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_6]] : (!fir.ref<!fir.type<_QFtest1Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL_9]] to %[[VAL_8]] : !fir.ref<i32>
|
||||
t1 = t2
|
||||
end subroutine test1
|
||||
|
||||
! Test a defined assignment on a simple struct.
|
||||
module m2
|
||||
type t
|
||||
integer a
|
||||
integer b
|
||||
end type t
|
||||
interface assignment (=)
|
||||
module procedure t_to_t
|
||||
end interface assignment (=)
|
||||
contains
|
||||
! CHECK-LABEL: func @_QMm2Ptest2
|
||||
subroutine test2
|
||||
type(t) :: t1, t2
|
||||
! CHECK: fir.call @_QMm2Pt_to_t(%{{.*}}, %{{.*}}) : (!fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>, !fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>) -> ()
|
||||
t1 = t2
|
||||
! CHECK: return
|
||||
end subroutine test2
|
||||
|
||||
! Swap elements on assignment.
|
||||
! CHECK-LABEL: func @_QMm2Pt_to_t(
|
||||
! CHECK-SAME: %[[a1:[^:]*]]: !fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>{{.*}}, %[[b1:[^:]*]]: !fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>{{.*}}) {
|
||||
subroutine t_to_t(a1,b1)
|
||||
type(t), intent(out) :: a1
|
||||
type(t), intent(in) :: b1
|
||||
! CHECK: %[[b:.*]] = fir.field_index b, !fir.type<_QMm2Tt{a:i32,b:i32}>
|
||||
! CHECK: %[[b1b:.*]] = fir.coordinate_of %[[b1]], %[[b]] : (!fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[v:.*]] = fir.load %[[b1b]] : !fir.ref<i32>
|
||||
! CHECK: %[[a:.*]] = fir.field_index a, !fir.type<_QMm2Tt{a:i32,b:i32}>
|
||||
! CHECK: %[[a1a:.*]] = fir.coordinate_of %[[a1]], %[[a]] : (!fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: fir.store %[[v]] to %[[a1a]] : !fir.ref<i32>
|
||||
! CHECK: %[[a:.*]] = fir.field_index a, !fir.type<_QMm2Tt{a:i32,b:i32}>
|
||||
! CHECK: %[[b1a:.*]] = fir.coordinate_of %[[b1]], %[[a]] : (!fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[v:.*]] = fir.load %[[b1a]] : !fir.ref<i32>
|
||||
! CHECK: %[[b:.*]] = fir.field_index b, !fir.type<_QMm2Tt{a:i32,b:i32}>
|
||||
! CHECK: %[[a1b:.*]] = fir.coordinate_of %[[a1]], %[[b]] : (!fir.ref<!fir.type<_QMm2Tt{a:i32,b:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: fir.store %[[v]] to %[[a1b]] : !fir.ref<i32>
|
||||
a1%a = b1%b
|
||||
a1%b = b1%a
|
||||
! CHECK: return
|
||||
end subroutine t_to_t
|
||||
end module m2
|
||||
|
||||
! CHECK-LABEL: func @_QPtest3
|
||||
subroutine test3
|
||||
type t
|
||||
character(LEN=20) :: m_c
|
||||
integer :: m_i
|
||||
end type t
|
||||
type(t) :: t1, t2
|
||||
! CHECK-DAG: %[[VAL_0:.*]] = fir.alloca !fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}> {{{.*}}uniq_name = "_QFtest3Et1"}
|
||||
! CHECK-DAG: %[[VAL_1:.*]] = fir.alloca !fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}> {{{.*}}uniq_name = "_QFtest3Et2"}
|
||||
! CHECK: %[[VAL_2:.*]] = fir.field_index m_c, !fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}>>, !fir.field) -> !fir.ref<!fir.char<1,20>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}>>, !fir.field) -> !fir.ref<!fir.char<1,20>>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 20 : index
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_5]] : (index) -> i64
|
||||
! CHECK: %[[VAL_8:.*]] = arith.muli %[[VAL_6]], %[[VAL_7]] : i64
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant false
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_4]] : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<!fir.char<1,20>>) -> !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.field_index m_i, !fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_12]] : (!fir.ref<!fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_14:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_12]] : (!fir.ref<!fir.type<_QFtest3Tt{m_c:!fir.char<1,20>,m_i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL_15]] to %[[VAL_14]] : !fir.ref<i32>
|
||||
t1 = t2
|
||||
! CHECK: return
|
||||
end subroutine test3
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_comp(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>>{{.*}}) {
|
||||
subroutine test_array_comp(t1, t2)
|
||||
type t
|
||||
real :: m_x(10)
|
||||
integer :: m_i
|
||||
end type t
|
||||
type(t) :: t1, t2
|
||||
|
||||
! CHECK: %[[VAL_2:.*]] = fir.field_index m_x, !fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>>, !fir.field) -> !fir.ref<!fir.array<10xf32>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>>, !fir.field) -> !fir.ref<!fir.array<10xf32>>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 9 : index
|
||||
! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_6]] {
|
||||
! CHECK: %[[VAL_9:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_8]] : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_8]] : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_10]] : !fir.ref<f32>
|
||||
! CHECK: fir.store %[[VAL_11]] to %[[VAL_9]] : !fir.ref<f32>
|
||||
! CHECK: }
|
||||
! CHECK: %[[VAL_12:.*]] = fir.field_index m_i, !fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>
|
||||
! CHECK: %[[VAL_13:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_12]] : (!fir.ref<!fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_14:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_12]] : (!fir.ref<!fir.type<_QFtest_array_compTt{m_x:!fir.array<10xf32>,m_i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL_15]] to %[[VAL_14]] : !fir.ref<i32>
|
||||
t1 = t2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_ptr_comp(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>>{{.*}}, %[[VAL_1]]: !fir.ref<!fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>>{{.*}}) {
|
||||
subroutine test_ptr_comp(t1, t2)
|
||||
type t
|
||||
complex, pointer :: ptr(:)
|
||||
integer :: m_i
|
||||
end type t
|
||||
type(t) :: t1, t2
|
||||
|
||||
! CHECK: %[[VAL_2:.*]] = fir.field_index ptr, !fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>
|
||||
! CHECK: %[[VAL_3:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_3]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>>
|
||||
! CHECK: fir.store %[[VAL_5]] to %[[VAL_4]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.field_index m_i, !fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_6]] : (!fir.ref<!fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_6]] : (!fir.ref<!fir.type<_QFtest_ptr_compTt{ptr:!fir.box<!fir.ptr<!fir.array<?x!fir.complex<4>>>>,m_i:i32}>>, !fir.field) -> !fir.ref<i32>
|
||||
! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
|
||||
! CHECK: fir.store %[[VAL_9]] to %[[VAL_8]] : !fir.ref<i32>
|
||||
t1 = t2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_box_assign(
|
||||
! CHECK-SAME: %[[t1:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>>{{.*}}, %[[t2:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>>{{.*}}) {
|
||||
subroutine test_box_assign(t1, t2)
|
||||
type t
|
||||
integer :: i
|
||||
end type t
|
||||
! Note: the implementation of this case is not optimal, the runtime call is overkill, but right now
|
||||
! lowering is conservative with derived type pointers because it does not make a difference between the
|
||||
! polymorphic and non polymorphic ones at the FIR level.
|
||||
type(t), pointer :: t1, t2
|
||||
! CHECK: %[[tmpBox:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>
|
||||
! CHECK: %[[t2Load:.*]] = fir.load %[[t2]] : !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>>
|
||||
! CHECK: %[[t1Load:.*]] = fir.load %[[t1]] : !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>>
|
||||
! CHECK: fir.store %[[t1Load]] to %[[tmpBox]] : !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>>
|
||||
! CHECK: %[[lhs:.*]] = fir.convert %[[tmpBox]] : (!fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[rhs:.*]] = fir.convert %[[t2Load]] : (!fir.box<!fir.ptr<!fir.type<_QFtest_box_assignTt{i:i32}>>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_FortranAAssign(%[[lhs]], %[[rhs]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
t1 = t2
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_alloc_comp(
|
||||
! CHECK-SAME: %[[t1:.*]]: !fir.ref<!fir.type<_QFtest_alloc_compTt{x:!fir.box<!fir.heap<!fir.array<?x?xf32>>>,i:i32}>>{{.*}}, %[[t2:.*]]: !fir.ref<!fir.type<_QFtest_alloc_compTt{x:!fir.box<!fir.heap<!fir.array<?x?xf32>>>,i:i32}>>{{.*}}) {
|
||||
subroutine test_alloc_comp(t1, t2)
|
||||
! Test that derived type assignment with allocatable components are using the
|
||||
! runtime to handle the deep copy.
|
||||
type t
|
||||
real, allocatable :: x(:, :)
|
||||
integer :: i
|
||||
end type
|
||||
type(t) :: t1, t2
|
||||
! CHECK: %[[tmpBox:.*]] = fir.alloca !fir.box<!fir.type<_QFtest_alloc_compTt{{.*}}>>
|
||||
! CHECK: %[[t1Box:.*]] = fir.embox %[[t1]] : (!fir.ref<!fir.type<_QFtest_alloc_compTt{{.*}}>>) -> !fir.box<!fir.type<_QFtest_alloc_compTt{{.*}}>>
|
||||
! CHECK: %[[t2Box:.*]] = fir.embox %[[t2]] : (!fir.ref<!fir.type<_QFtest_alloc_compTt{{.*}}>>) -> !fir.box<!fir.type<_QFtest_alloc_compTt{{.*}}>>
|
||||
! CHECK: fir.store %[[t1Box]] to %[[tmpBox]] : !fir.ref<!fir.box<!fir.type<_QFtest_alloc_compTt{{.*}}>>>
|
||||
! CHECK: %[[lhs:.*]] = fir.convert %[[tmpBox]] : (!fir.ref<!fir.box<!fir.type<_QFtest_alloc_compTt{{.*}}>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: %[[rhs:.*]] = fir.convert %[[t2Box]] : (!fir.box<!fir.type<_QFtest_alloc_compTt{{.*}}>>) -> !fir.box<none>
|
||||
! CHECK: fir.call @_FortranAAssign(%[[lhs]], %[[rhs]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
t1 = t2
|
||||
end subroutine
|
||||
|
||||
! Reinstate this test when polymorphic types are more fully supported.
|
||||
!
|
||||
!module component_with_user_def_assign
|
||||
! type t0
|
||||
! integer :: i
|
||||
! integer :: j
|
||||
! contains
|
||||
! procedure :: user_def
|
||||
! generic :: assignment(=) => user_def
|
||||
! end type
|
||||
! interface
|
||||
! subroutine user_def(other, self)
|
||||
! import t0
|
||||
! class(t0), intent(out) :: other
|
||||
! class(t0), intent(in) :: self
|
||||
! end subroutine
|
||||
! end interface
|
||||
|
||||
! ! Assignments of type(t) must call the user defined assignment for component a.
|
||||
! ! Currently this is delegated to the runtime.
|
||||
! type t
|
||||
! type(t0) :: a
|
||||
! integer :: i
|
||||
! end type
|
||||
|
||||
!contains
|
||||
! ! cHECK-LABEL: func @_QMcomponent_with_user_def_assignPtest(
|
||||
! ! cHECK-SAME: %[[t1:.*]]: !fir.ref<!fir.type<_QMcomponent_with_user_def_assignTt{a:!fir.type<_QMcomponent_with_user_def_assignTt0{i:i32,j:i32}>,i:i32}>>{{.*}}, %[[t2:.*]]: !fir.ref<!fir.type<_QMcomponent_with_user_def_assignTt{a:!fir.type<_QMcomponent_with_user_def_assignTt0{i:i32,j:i32}>,i:i32}>>{{.*}}) {
|
||||
! subroutine test(t1, t2)
|
||||
! type(t) :: t1, t2
|
||||
! ! cHECK: %[[tmpBox:.*]] = fir.alloca !fir.box<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>
|
||||
! ! cHECK: %[[t1Box:.*]] = fir.embox %[[t1]] : (!fir.ref<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>) -> !fir.box<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>
|
||||
! ! cHECK: %[[t2Box:.*]] = fir.embox %[[t2]] : (!fir.ref<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>) -> !fir.box<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>
|
||||
! ! cHECK: fir.store %[[t1Box]] to %[[tmpBox]] : !fir.ref<!fir.box<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>>
|
||||
! ! cHECK: %[[lhs:.*]] = fir.convert %[[tmpBox]] : (!fir.ref<!fir.box<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>>) -> !fir.ref<!fir.box<none>>
|
||||
! ! cHECK: %[[rhs:.*]] = fir.convert %[[t2Box]] : (!fir.box<!fir.type<_QMcomponent_with_user_def_assignTt{{.*}}>>) -> !fir.box<none>
|
||||
! ! cHECK: fir.call @_FortranAAssign(%[[lhs]], %[[rhs]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
|
||||
! t1 = t2
|
||||
! end subroutine
|
||||
!end module
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
! Test lowering of derived type descriptors builtin data
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
subroutine foo()
|
||||
real, save, target :: init_values(10, 10)
|
||||
type sometype
|
||||
integer :: num = 42
|
||||
real, pointer :: values(:, :) => init_values
|
||||
end type
|
||||
type(sometype), allocatable, save :: x(:)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.n.num constant : !fir.char<1,3> {
|
||||
! CHECK: %[[res:.*]] = fir.string_lit "num"(3) : !fir.char<1,3>
|
||||
! CHECK: fir.has_value %[[res]] : !fir.char<1,3>
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.di.sometype.num constant : i32
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.n.values constant : !fir.char<1,6> {
|
||||
! CHECK: %[[res:.*]] = fir.string_lit "values"(6) : !fir.char<1,6>
|
||||
! CHECK: fir.has_value %[[res]] : !fir.char<1,6>
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.n.sometype constant : !fir.char<1,8> {
|
||||
! CHECK: %[[res:.*]] = fir.string_lit "sometype"(8) : !fir.char<1,8>
|
||||
! CHECK: fir.has_value %[[res]] : !fir.char<1,8>
|
||||
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.di.sometype.values constant : !fir.type<_QFfooT.dp.sometype.values{values:!fir.box<!fir.ptr<!fir.array<?x?xf32>>>}> {
|
||||
! CHECK: fir.address_of(@_QFfooEinit_values)
|
||||
! CHECK: }
|
||||
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.dt.sometype constant {{.*}} {
|
||||
!CHECK: fir.address_of(@_QFfooE.n.sometype)
|
||||
!CHECK: fir.address_of(@_QFfooE.c.sometype)
|
||||
! CHECK:}
|
||||
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFfooE.c.sometype constant {{.*}} {
|
||||
! CHECK: fir.address_of(@_QFfooE.n.num)
|
||||
! CHECK: fir.address_of(@_QFfooE.di.sometype.num) : !fir.ref<i32>
|
||||
! CHECK: fir.address_of(@_QFfooE.n.values)
|
||||
! CHECK: fir.address_of(@_QFfooE.di.sometype.values)
|
||||
! CHECK: }
|
||||
|
||||
subroutine char_comp_init()
|
||||
implicit none
|
||||
type t
|
||||
character(8) :: name='Empty'
|
||||
end type t
|
||||
type(t) :: a
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFchar_comp_initE.di.t.name constant : !fir.char<1,8> {
|
||||
! CHECK: %[[res:.*]] = fir.string_lit "Empty "(8) : !fir.char<1,8>
|
||||
! CHECK: fir.has_value %[[res]] : !fir.char<1,8>
|
||||
|
||||
! CHECK-LABEL: fir.global linkonce_odr @_QFchar_comp_initE.c.t constant : {{.*}} {
|
||||
! CHECK: fir.address_of(@_QFchar_comp_initE.di.t.name) : !fir.ref<!fir.char<1,8>>
|
||||
! CHECK: }
|
||||
Loading…
Reference in New Issue