| ! Test lowering of pointer components | |
| ! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s | |
| module pcomp | |
| 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, pointer :: x | |
| end subroutine | |
| subroutine takes_real_array_pointer(x) | |
| real, pointer :: x(:) | |
| end subroutine | |
| subroutine takes_logical(x) | |
| logical :: x | |
| end subroutine | |
| end interface | |
| type real_p0 | |
| real, pointer :: p | |
| end type | |
| type real_p1 | |
| real, pointer :: p(:) | |
| end type | |
| type cst_char_p0 | |
| character(10), pointer :: p | |
| end type | |
| type cst_char_p1 | |
| character(10), pointer :: p(:) | |
| end type | |
| type def_char_p0 | |
| character(:), pointer :: p | |
| end type | |
| type def_char_p1 | |
| character(:), pointer :: p(:) | |
| end type | |
| type derived_p0 | |
| type(t), pointer :: p | |
| end type | |
| type derived_p1 | |
| type(t), pointer :: p(:) | |
| end type | |
| real, target :: real_target, real_array_target(100) | |
| character(10), target :: char_target, char_array_target(100) | |
| contains | |
| ! ----------------------------------------------------------------------------- | |
| ! Test pointer component references | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPref_scalar_real_p( | |
| ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.type<_QMpcompTreal_p0{p:!fir.box<!fir.ptr<f32>>}>>{{.*}}, %[[ARG1:.*]]: !fir.ref<!fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>{{.*}}, %[[ARG2:.*]]: !fir.ref<!fir.array<100x!fir.type<_QMpcompTreal_p0{p:!fir.box<!fir.ptr<f32>>}>>>{{.*}}, %[[ARG3:.*]]: !fir.ref<!fir.array<100x!fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>>{{.*}}) { | |
| subroutine ref_scalar_real_p(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[VAL:.*]] = fir.convert %[[ADDR]] | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[VAL]]) | |
| call takes_real_scalar(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[VAL:.*]] = fir.convert %[[ADDR]] | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[VAL]]) | |
| call takes_real_scalar(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[ELT]]) | |
| call takes_real_scalar(p1_0%p(7)) | |
| ! CHECK: %[[ELT_ARR:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT_ARR]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[ELT]]) | |
| call takes_real_scalar(p1_1(5)%p(7)) | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPref_array_real_p( | |
| ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>{{.*}}, %[[ARG1:.*]]: !fir.ref<!fir.array<100x!fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>>{{.*}}) { | |
| subroutine ref_array_real_p(p1_0, p1_1) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[SLICE:.*]] = hlfir.designate %[[LOAD]] (%c20{{.*}}:%c50{{.*}}:%c2{{.*}}) | |
| ! CHECK: %[[BOX:.*]] = fir.convert %[[SLICE]] | |
| ! CHECK: fir.call @_QPtakes_real_array(%[[BOX]]) | |
| call takes_real_array(p1_0%p(20:50:2)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[SLICE:.*]] = hlfir.designate %[[LOAD]] (%c20{{.*}}:%c50{{.*}}:%c2{{.*}}) | |
| ! CHECK: %[[BOX:.*]] = fir.convert %[[SLICE]] | |
| ! CHECK: fir.call @_QPtakes_real_array(%[[BOX]]) | |
| call takes_real_array(p1_1(5)%p(20:50:2)) | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPassign_scalar_real_p | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine assign_scalar_real_p(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: hlfir.assign %{{.*}} to %[[ADDR]] | |
| p0_0%p = 1. | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: hlfir.assign %{{.*}} to %[[ADDR]] | |
| p0_1(5)%p = 2. | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: hlfir.assign %{{.*}} to %[[ADDR]] | |
| p1_0%p(7) = 3. | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: hlfir.assign %{{.*}} to %[[ADDR]] | |
| p1_1(5)%p(7) = 4. | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPref_scalar_cst_char_p | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine ref_scalar_cst_char_p(p0_0, p1_0, p0_1, p1_1) | |
| type(cst_char_p0) :: p0_0, p0_1(100) | |
| type(cst_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[VAL:.*]] = fir.convert %[[ADDR]] | |
| ! CHECK: %[[BOXCHAR:.*]] = fir.emboxchar %[[VAL]], %c10{{.*}} | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[VAL:.*]] = fir.convert %[[ADDR]] | |
| ! CHECK: %[[BOXCHAR:.*]] = fir.emboxchar %[[VAL]], %c10{{.*}} | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: %[[BOXCHAR:.*]] = fir.emboxchar %[[ADDR]], %c10{{.*}} | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p1_0%p(7)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: %[[BOXCHAR:.*]] = fir.emboxchar %[[ADDR]], %c10{{.*}} | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p1_1(5)%p(7)) | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPref_scalar_def_char_p | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine ref_scalar_def_char_p(p0_0, p1_0, p0_1, p1_1) | |
| type(def_char_p0) :: p0_0, p0_1(100) | |
| type(def_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[LOAD2:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[LEN:.*]] = fir.box_elesize %[[LOAD2]] | |
| ! CHECK: %[[BOXCHAR:.*]] = fir.emboxchar %[[ADDR]], %[[LEN]] | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[LOAD2:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[LEN:.*]] = fir.box_elesize %[[LOAD2]] | |
| ! CHECK: %[[BOXCHAR:.*]] = fir.emboxchar %[[ADDR]], %[[LEN]] | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[LEN:.*]] = fir.box_elesize %[[LOAD]] | |
| ! CHECK: %[[BOXCHAR:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) typeparams %[[LEN]] | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p1_0%p(7)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[LEN:.*]] = fir.box_elesize %[[LOAD]] | |
| ! CHECK: %[[BOXCHAR:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) typeparams %[[LEN]] | |
| ! CHECK: fir.call @_QPtakes_char_scalar(%[[BOXCHAR]]) | |
| call takes_char_scalar(p1_1(5)%p(7)) | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPref_scalar_derived | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine ref_scalar_derived(p0_0, p1_0, p0_1, p1_1) | |
| type(derived_p0) :: p0_0, p0_1(100) | |
| type(derived_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[X:.*]] = hlfir.designate %[[ADDR]]{"x"} | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[X]]) | |
| call takes_real_scalar(p0_0%p%x) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: %[[X:.*]] = hlfir.designate %[[ADDR]]{"x"} | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[X]]) | |
| call takes_real_scalar(p0_1(5)%p%x) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: %[[X:.*]] = hlfir.designate %[[ELT]]{"x"} | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[X]]) | |
| call takes_real_scalar(p1_0%p(7)%x) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ELT2:.*]] = hlfir.designate %[[LOAD]] (%c7{{.*}}) | |
| ! CHECK: %[[X:.*]] = hlfir.designate %[[ELT2]]{"x"} | |
| ! CHECK: fir.call @_QPtakes_real_scalar(%[[X]]) | |
| call takes_real_scalar(p1_1(5)%p(7)%x) | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test passing pointer component references as pointers | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPpass_real_p | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine pass_real_p(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_QPtakes_real_scalar_pointer(%[[P]]) | |
| call takes_real_scalar_pointer(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_QPtakes_real_scalar_pointer(%[[P]]) | |
| call takes_real_scalar_pointer(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_QPtakes_real_array_pointer(%[[P]]) | |
| call takes_real_array_pointer(p1_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_QPtakes_real_array_pointer(%[[P]]) | |
| call takes_real_array_pointer(p1_1(5)%p) | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test usage in intrinsics where pointer aspect matters | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPassociated_p | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine associated_p(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(def_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: fir.convert %[[ADDR]] : (!fir.ptr<f32>) -> i64 | |
| call takes_logical(associated(p0_0%p)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: fir.convert %[[ADDR]] : (!fir.ptr<f32>) -> i64 | |
| call takes_logical(associated(p0_1(5)%p)) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: fir.convert %[[ADDR]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> i64 | |
| call takes_logical(associated(p1_0%p)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[LOAD:.*]] = fir.load %[[P]] | |
| ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[LOAD]] | |
| ! CHECK: fir.convert %[[ADDR]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> i64 | |
| call takes_logical(associated(p1_1(5)%p)) | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test pointer assignment of components | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPpassoc_real | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine passoc_real(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p0_0%p => real_target | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p0_1(5)%p => real_target | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p1_0%p => real_array_target | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p1_1(5)%p => real_array_target | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPpassoc_char | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine passoc_char(p0_0, p1_0, p0_1, p1_1) | |
| type(cst_char_p0) :: p0_0, p0_1(100) | |
| type(def_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p0_0%p => char_target | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p0_1(5)%p => char_target | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p1_0%p => char_array_target | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.store {{.*}} to %[[P]] | |
| p1_1(5)%p => char_array_target | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test nullify of components | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPnullify_test | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine nullify_test(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(def_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: %[[NULL:.*]] = fir.zero_bits !fir.ptr<f32> | |
| ! CHECK: %[[BOX:.*]] = fir.embox %[[NULL]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>> | |
| ! CHECK: fir.store %[[BOX]] to %[[P]] | |
| nullify(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[NULL:.*]] = fir.zero_bits !fir.ptr<f32> | |
| ! CHECK: %[[BOX:.*]] = fir.embox %[[NULL]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>> | |
| ! CHECK: fir.store %[[BOX]] to %[[P]] | |
| nullify(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: %[[NULL:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x!fir.char<1,?>>> | |
| ! CHECK: %[[BOX:.*]] = fir.embox %[[NULL]] | |
| ! CHECK: fir.store %[[BOX]] to %[[P]] | |
| nullify(p1_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: %[[NULL:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x!fir.char<1,?>>> | |
| ! CHECK: %[[BOX:.*]] = fir.embox %[[NULL]] | |
| ! CHECK: fir.store %[[BOX]] to %[[P]] | |
| nullify(p1_1(5)%p) | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test allocation | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPallocate_real | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine allocate_real(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerSetBounds | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p1_0%p(100)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerSetBounds | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p1_1(5)%p(100)) | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPallocate_cst_char | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine allocate_cst_char(p0_0, p1_0, p0_1, p1_1) | |
| type(cst_char_p0) :: p0_0, p0_1(100) | |
| type(cst_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerSetBounds | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p1_0%p(100)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerSetBounds | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(p1_1(5)%p(100)) | |
| end subroutine | |
| ! CHECK-LABEL: func.func @_QMpcompPallocate_def_char | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine allocate_def_char(p0_0, p1_0, p0_1, p1_1) | |
| type(def_char_p0) :: p0_0, p0_1(100) | |
| type(def_char_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(character(18)::p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(character(18)::p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerSetBounds | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(character(18)::p1_0%p(100)) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerSetBounds | |
| ! CHECK: fir.call @_FortranAPointerAllocate | |
| allocate(character(18)::p1_1(5)%p(100)) | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test deallocation | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPdeallocate_real | |
| ! CHECK-SAME: (%[[ARG0:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %[[ARG2:.*]]: {{.*}}, %[[ARG3:.*]]: {{.*}}) | |
| subroutine deallocate_real(p0_0, p1_0, p0_1, p1_1) | |
| type(real_p0) :: p0_0, p0_1(100) | |
| type(real_p1) :: p1_0, p1_1(100) | |
| ! CHECK: %[[P0_0_DECL:.*]]:2 = hlfir.declare %[[ARG0]] | |
| ! CHECK: %[[P0_1_DECL:.*]]:2 = hlfir.declare %[[ARG2]] | |
| ! CHECK: %[[P1_0_DECL:.*]]:2 = hlfir.declare %[[ARG1]] | |
| ! CHECK: %[[P1_1_DECL:.*]]:2 = hlfir.declare %[[ARG3]] | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P0_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerDeallocate | |
| deallocate(p0_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P0_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerDeallocate | |
| deallocate(p0_1(5)%p) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[P1_0_DECL]]#0{"p"} | |
| ! CHECK: fir.call @_FortranAPointerDeallocate | |
| deallocate(p1_0%p) | |
| ! CHECK: %[[ELT:.*]] = hlfir.designate %[[P1_1_DECL]]#0 (%c5{{.*}}) | |
| ! CHECK: %[[P:.*]] = hlfir.designate %[[ELT]]{"p"} | |
| ! CHECK: fir.call @_FortranAPointerDeallocate | |
| deallocate(p1_1(5)%p) | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test a very long component | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPvery_long | |
| ! CHECK-SAME: (%[[X:.*]]: {{.*}}) | |
| subroutine very_long(x) | |
| type t0 | |
| real :: f | |
| end type | |
| type t1 | |
| type(t0), allocatable :: e(:) | |
| end type | |
| type t2 | |
| type(t1) :: d(10) | |
| end type | |
| type t3 | |
| type(t2) :: c | |
| end type | |
| type t4 | |
| type(t3), pointer :: b | |
| end type | |
| type t5 | |
| type(t4) :: a | |
| end type | |
| type(t5) :: x(:, :, :, :, :) | |
| ! CHECK: %[[X_DECL:.*]]:2 = hlfir.declare %[[X]] | |
| ! CHECK: %[[X_ELT:.*]] = hlfir.designate %[[X_DECL]]#0 (%c1{{.*}}, %c2{{.*}}, %c3{{.*}}, %c4{{.*}}, %c5{{.*}}) | |
| ! CHECK: %[[A:.*]] = hlfir.designate %[[X_ELT]]{"a"} | |
| ! CHECK: %[[B:.*]] = hlfir.designate %[[A]]{"b"} | |
| ! CHECK: %[[B_LOAD:.*]] = fir.load %[[B]] | |
| ! CHECK: %[[B_ADDR:.*]] = fir.box_addr %[[B_LOAD]] | |
| ! CHECK: %[[C:.*]] = hlfir.designate %[[B_ADDR]]{"c"} | |
| ! CHECK: %[[D_ELT:.*]] = hlfir.designate %[[C]]{"d"} <%{{.*}}> (%c6{{.*}}) | |
| ! CHECK: %[[E:.*]] = hlfir.designate %[[D_ELT]]{"e"} | |
| ! CHECK: %[[E_LOAD:.*]] = fir.load %[[E]] | |
| ! CHECK: %[[E_ELT:.*]] = hlfir.designate %[[E_LOAD]] (%c7{{.*}}) | |
| ! CHECK: %[[F:.*]] = hlfir.designate %[[E_ELT]]{"f"} | |
| ! CHECK: fir.load %[[F]] | |
| print *, x(1,2,3,4,5)%a%b%c%d(6)%e(7)%f | |
| end subroutine | |
| ! ----------------------------------------------------------------------------- | |
| ! Test a recursive derived type reference | |
| ! ----------------------------------------------------------------------------- | |
| ! CHECK-LABEL: func.func @_QMpcompPtest_recursive | |
| ! CHECK-SAME: (%[[X:.*]]: {{.*}}) | |
| subroutine test_recursive(x) | |
| type t | |
| integer :: i | |
| type(t), pointer :: next | |
| end type | |
| type(t) :: x | |
| ! CHECK: %[[X_DECL:.*]]:2 = hlfir.declare %[[X]] | |
| ! CHECK: %[[NEXT:.*]] = hlfir.designate %[[X_DECL]]#0{"next"} | |
| ! CHECK: %[[NEXT_LOAD:.*]] = fir.load %[[NEXT]] | |
| ! CHECK: %[[NEXT_ADDR:.*]] = fir.box_addr %[[NEXT_LOAD]] | |
| ! CHECK: %[[NEXT2:.*]] = hlfir.designate %[[NEXT_ADDR]]{"next"} | |
| ! CHECK: %[[NEXT2_LOAD:.*]] = fir.load %[[NEXT2]] | |
| ! CHECK: %[[NEXT2_ADDR:.*]] = fir.box_addr %[[NEXT2_LOAD]] | |
| ! CHECK: %[[NEXT3:.*]] = hlfir.designate %[[NEXT2_ADDR]]{"next"} | |
| ! CHECK: %[[NEXT3_LOAD:.*]] = fir.load %[[NEXT3]] | |
| ! CHECK: %[[NEXT3_ADDR:.*]] = fir.box_addr %[[NEXT3_LOAD]] | |
| ! CHECK: %[[I:.*]] = hlfir.designate %[[NEXT3_ADDR]]{"i"} | |
| ! CHECK: fir.load %[[I]] | |
| print *, x%next%next%next%i | |
| end subroutine | |
| end module | |
| ! ----------------------------------------------------------------------------- | |
| ! Test initial data target | |
| ! ----------------------------------------------------------------------------- | |
| module pinit | |
| use pcomp | |
| ! CHECK-LABEL: fir.global {{.*}}@_QMpinitEarp0 | |
| ! CHECK-DAG: %[[undef:.*]] = fir.undefined | |
| ! CHECK-DAG: %[[target:.*]] = fir.address_of(@_QMpcompEreal_target) | |
| ! CHECK: %[[decl:.*]]:2 = hlfir.declare %[[target]] | |
| ! CHECK: %[[box:.*]] = fir.embox %[[decl]]#0 : (!fir.ref<f32>) -> !fir.box<f32> | |
| ! CHECK: %[[rebox:.*]] = fir.rebox %[[box]] : (!fir.box<f32>) -> !fir.box<!fir.ptr<f32>> | |
| ! CHECK: %[[insert:.*]] = fir.insert_value %[[undef]], %[[rebox]], ["p", !fir.type<_QMpcompTreal_p0{p:!fir.box<!fir.ptr<f32>>}>] : | |
| ! CHECK: fir.has_value %[[insert]] | |
| type(real_p0) :: arp0 = real_p0(real_target) | |
| ! CHECK-LABEL: fir.global @_QMpinitEbrp1 : !fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}> { | |
| ! CHECK: %[[VAL_0:.*]] = fir.undefined !fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}> | |
| ! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QMpcompEreal_array_target) : !fir.ref<!fir.array<100xf32>> | |
| ! CHECK: %[[VAL_3:.*]] = arith.constant 100 : index | |
| ! CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1> | |
| ! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_18]]) | |
| ! CHECK-DAG: %[[VAL_7:.*]] = arith.constant 10 : index | |
| ! CHECK-DAG: %[[VAL_9:.*]] = arith.constant 5 : index | |
| ! CHECK-DAG: %[[VAL_11:.*]] = arith.constant 50 : index | |
| ! CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_DECL]]#0 (%[[VAL_7]]:%[[VAL_11]]:%[[VAL_9]]) | |
| ! CHECK: %[[VAL_21:.*]] = fir.rebox %[[VAL_19]] : (!fir.box<!fir.array<9xf32>>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>> | |
| ! CHECK: %[[VAL_22:.*]] = fir.insert_value %[[VAL_0]], %[[VAL_21]], ["p", !fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>] : (!fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>, !fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}> | |
| ! CHECK: fir.has_value %[[VAL_22]] : !fir.type<_QMpcompTreal_p1{p:!fir.box<!fir.ptr<!fir.array<?xf32>>>}> | |
| ! CHECK: } | |
| type(real_p1) :: brp1 = real_p1(real_array_target(10:50:5)) | |
| ! CHECK-LABEL: fir.global {{.*}}@_QMpinitEccp0 | |
| ! CHECK-DAG: %[[undef:.*]] = fir.undefined | |
| ! CHECK-DAG: %[[target:.*]] = fir.address_of(@_QMpcompEchar_target) | |
| ! CHECK: %[[decl:.*]]:2 = hlfir.declare %[[target]] | |
| ! CHECK: %[[box:.*]] = fir.embox %[[decl]]#0 : (!fir.ref<!fir.char<1,10>>) -> !fir.box<!fir.char<1,10>> | |
| ! CHECK: %[[rebox:.*]] = fir.rebox %[[box]] : (!fir.box<!fir.char<1,10>>) -> !fir.box<!fir.ptr<!fir.char<1,10>>> | |
| ! CHECK: %[[insert:.*]] = fir.insert_value %[[undef]], %[[rebox]], ["p", !fir.type<_QMpcompTcst_char_p0{p:!fir.box<!fir.ptr<!fir.char<1,10>>>}>] : | |
| ! CHECK: fir.has_value %[[insert]] | |
| type(cst_char_p0) :: ccp0 = cst_char_p0(char_target) | |
| ! CHECK-LABEL: fir.global {{.*}}@_QMpinitEdcp1 | |
| ! CHECK-DAG: %[[undef:.*]] = fir.undefined | |
| ! CHECK-DAG: %[[target:.*]] = fir.address_of(@_QMpcompEchar_array_target) | |
| ! CHECK-DAG: %[[shape:.*]] = fir.shape %c100{{.*}} | |
| ! CHECK: %[[decl:.*]]:2 = hlfir.declare %[[target]](%[[shape]]) | |
| ! CHECK-DAG: %[[shape2:.*]] = fir.shape %c100{{.*}} | |
| ! CHECK-DAG: %[[box:.*]] = fir.embox %[[decl]]#0(%[[shape2]]) : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<100x!fir.char<1,10>>> | |
| ! CHECK-DAG: %[[rebox:.*]] = fir.rebox %[[box]] : (!fir.box<!fir.array<100x!fir.char<1,10>>>) -> !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>> | |
| ! CHECK: %[[insert:.*]] = fir.insert_value %[[undef]], %[[rebox]], ["p", !fir.type<_QMpcompTdef_char_p1{p:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>] : | |
| ! CHECK: fir.has_value %[[insert]] | |
| type(def_char_p1) :: dcp1 = def_char_p1(char_array_target) | |
| end module |