forked from OSchip/llvm-project
[flang][NFC] Add pointer dummy arguments tests
This patch adds test for calls with POINTER dummy arguments on the caller side. It also fixes some formatting error that was introduced when upstreaming the other pointer tests. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122238 Co-authored-by: Jean Perier <jperier@nvidia.com>
This commit is contained in:
Valentin Clement
parent
631a643940
commit
3de6b1ce0d
|
|
@ -0,0 +1,142 @@
|
|||
! Test calls with POINTER dummy arguments on the caller side.
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
module call_defs
|
||||
interface
|
||||
subroutine scalar_ptr(p)
|
||||
integer, pointer, intent(in) :: p
|
||||
end subroutine
|
||||
subroutine array_ptr(p)
|
||||
integer, pointer, intent(in) :: p(:)
|
||||
end subroutine
|
||||
subroutine char_array_ptr(p)
|
||||
character(:), pointer, intent(in) :: p(:)
|
||||
end subroutine
|
||||
subroutine non_deferred_char_array_ptr(p)
|
||||
character(10), pointer, intent(in) :: p(:)
|
||||
end subroutine
|
||||
end interface
|
||||
contains
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing POINTER actual arguments
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_ptr_to_scalar_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<i32>>> {fir.bindc_name = "p"}) {
|
||||
subroutine test_ptr_to_scalar_ptr(p)
|
||||
integer, pointer :: p
|
||||
! CHECK: fir.call @_QPscalar_ptr(%[[VAL_0]]) : (!fir.ref<!fir.box<!fir.ptr<i32>>>) -> ()
|
||||
call scalar_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_ptr_to_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> {fir.bindc_name = "p"}) {
|
||||
subroutine test_ptr_to_array_ptr(p)
|
||||
integer, pointer :: p(:)
|
||||
call array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_ptr_to_char_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>> {fir.bindc_name = "p"}) {
|
||||
subroutine test_ptr_to_char_array_ptr(p)
|
||||
character(:), pointer :: p(:)
|
||||
! CHECK: fir.call @_QPchar_array_ptr(%[[VAL_0]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>) -> ()
|
||||
call char_array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_ptr_to_non_deferred_char_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>> {fir.bindc_name = "p"}) {
|
||||
subroutine test_ptr_to_non_deferred_char_array_ptr(p)
|
||||
character(:), pointer :: p(:)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>>
|
||||
! CHECK: fir.call @_QPnon_deferred_char_array_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>>) -> ()
|
||||
call non_deferred_char_array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test passing non-POINTER actual arguments (implicit pointer assignment)
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_non_ptr_to_scalar_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "p", fir.target}) {
|
||||
subroutine test_non_ptr_to_scalar_ptr(p)
|
||||
integer, target :: p
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<i32>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<i32>) -> !fir.box<!fir.ptr<i32>>
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: fir.call @_QPscalar_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<i32>>>) -> ()
|
||||
call scalar_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_non_ptr_to_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "p", fir.target}) {
|
||||
subroutine test_non_ptr_to_array_ptr(p)
|
||||
integer, target :: p(:)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.rebox %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
|
||||
! CHECK: fir.call @_QParray_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> ()
|
||||
call array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_non_ptr_to_array_ptr_lower_bounds(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "p", fir.target}) {
|
||||
subroutine test_non_ptr_to_array_ptr_lower_bounds(p)
|
||||
! Test that local lower bounds of the actual argument are applied.
|
||||
integer, target :: p(42:)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 42 : i64
|
||||
! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i64) -> index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.shift %[[VAL_3]] : (index) -> !fir.shift<1>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.rebox %[[VAL_0]](%[[VAL_4]]) : (!fir.box<!fir.array<?xi32>>, !fir.shift<1>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_5]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
|
||||
! CHECK: fir.call @_QParray_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> ()
|
||||
call array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_non_ptr_to_char_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1> {fir.bindc_name = "p", fir.target}) {
|
||||
subroutine test_non_ptr_to_char_array_ptr(p)
|
||||
character(10), target :: p(10)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,10>>>
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 10 : index
|
||||
! CHECK: %[[VAL_6:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_4]] : (!fir.ref<!fir.array<10x!fir.char<1,10>>>) -> !fir.ref<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_7]](%[[VAL_6]]) typeparams %[[VAL_3]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.store %[[VAL_8]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
! CHECK: fir.call @_QPchar_array_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>) -> ()
|
||||
call char_array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_non_ptr_to_non_deferred_char_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,?>>> {fir.bindc_name = "p", fir.target}) {
|
||||
subroutine test_non_ptr_to_non_deferred_char_array_ptr(p)
|
||||
character(*), target :: p(:)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.rebox %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>>
|
||||
! CHECK: fir.call @_QPnon_deferred_char_array_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>>) -> ()
|
||||
call non_deferred_char_array_ptr(p)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QMcall_defsPtest_allocatable_to_array_ptr(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {fir.bindc_name = "p", fir.target}) {
|
||||
subroutine test_allocatable_to_array_ptr(p)
|
||||
integer, allocatable, target :: p(:)
|
||||
call array_ptr(p)
|
||||
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_3]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_5:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
|
||||
! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_4]]#0, %[[VAL_4]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.embox %[[VAL_5]](%[[VAL_6]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>>
|
||||
! CHECK: fir.store %[[VAL_7]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
|
||||
! CHECK: fir.call @_QParray_ptr(%[[VAL_1]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> ()
|
||||
end subroutine
|
||||
|
||||
end module
|
||||
|
|
@ -16,33 +16,33 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[box:.*]] = fir.embox %[[x]] : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}}, %[[x:.*]]: !fir.boxchar<1> {{{.*}}, fir.target})
|
||||
subroutine test_scalar_char(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}}, %[[x:.*]]: !fir.boxchar<1> {{{.*}}, fir.target})
|
||||
subroutine test_scalar_char(p, x)
|
||||
character(*), target :: x
|
||||
character(:), pointer :: p
|
||||
! CHECK: %[[c:.*]]:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[c]]#0 typeparams %[[c]]#1 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.ref<!fir.array<100xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.ref<!fir.array<100xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array(p, x)
|
||||
real, target :: x(100)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c100{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]](%[[shape]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>{{.*}}, %[[x:.*]]: !fir.boxchar<1> {{{.*}}, fir.target}) {
|
||||
subroutine test_array_char(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_array_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>{{.*}}, %[[x:.*]]: !fir.boxchar<1> {{{.*}}, fir.target}) {
|
||||
subroutine test_array_char(p, x)
|
||||
character(*), target :: x(100)
|
||||
character(:), pointer :: p(:)
|
||||
! CHECK: %[[c:.*]]:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
|
||||
|
|
@ -52,42 +52,42 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[box:.*]] = fir.embox %[[xaddr2]](%[[shape]]) typeparams %[[c]]#1
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from rhs if no bounds spec.
|
||||
! CHECK-LABEL: func @_QPtest_array_with_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
subroutine test_array_with_lbs(p, x)
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from rhs if no bounds spec.
|
||||
! CHECK-LABEL: func @_QPtest_array_with_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
subroutine test_array_with_lbs(p, x)
|
||||
real, target :: x(51:150)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[shape:.*]] = fir.shape_shift %c51{{.*}}, %c100{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %{{.*}}(%[[shape]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shapeshift<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test pointer assignments with bound specs to contiguous right-hand side
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test pointer assignments with bound specs to contiguous right-hand side
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from bound spec if specified
|
||||
! CHECK-LABEL: func @_QPtest_array_with_new_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
subroutine test_array_with_new_lbs(p, x)
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from bound spec if specified
|
||||
! CHECK-LABEL: func @_QPtest_array_with_new_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
subroutine test_array_with_new_lbs(p, x)
|
||||
real, target :: x(51:150)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[shape:.*]] = fir.shape_shift %c4{{.*}}, %c100{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %{{.*}}(%[[shape]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shapeshift<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p(4:) => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! Test F2018 10.2.2.3 point 9: bounds remapping
|
||||
! CHECK-LABEL: func @_QPtest_array_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>{{.*}}, %[[x:.*]]: !fir.ref<!fir.array<100xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_remap(p, x)
|
||||
! Test F2018 10.2.2.3 point 9: bounds remapping
|
||||
! CHECK-LABEL: func @_QPtest_array_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>{{.*}}, %[[x:.*]]: !fir.ref<!fir.array<100xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_remap(p, x)
|
||||
real, target :: x(100)
|
||||
real, pointer :: p(:, :)
|
||||
! CHECK-DAG: %[[c2_idx:.*]] = fir.convert %c2{{.*}} : (i64) -> index
|
||||
|
|
@ -103,11 +103,11 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[box:.*]] = fir.embox %[[addrCast]](%[[shape]]) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
p(2:11, 3:12) => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_char_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?x!fir.char<1,?>>>>>{{.*}}, %[[x:.*]]: !fir.boxchar<1> {{{.*}}, fir.target})
|
||||
subroutine test_array_char_remap(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_array_char_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?x!fir.char<1,?>>>>>{{.*}}, %[[x:.*]]: !fir.boxchar<1> {{{.*}}, fir.target})
|
||||
subroutine test_array_char_remap(p, x)
|
||||
! CHECK: %[[unbox:.*]]:2 = fir.unboxchar %[[x]]
|
||||
character(*), target :: x(100)
|
||||
character(:), pointer :: p(:, :)
|
||||
|
|
@ -119,27 +119,27 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[box:.*]] = fir.embox %{{.*}}(%[[shape]]) typeparams %[[unbox]]#1 : (!fir.ref<!fir.array<?x?x!fir.char<1,?>>>, !fir.shapeshift<2>, index) -> !fir.box<!fir.ptr<!fir.array<?x?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]]
|
||||
p(2:11, 3:12) => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test simple pointer assignments to non contiguous right-hand side
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test simple pointer assignments to non contiguous right-hand side
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_rhs(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_rhs(p, x)
|
||||
real, target :: x(:)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[rebox:.*]] = fir.rebox %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[rebox]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from rhs if no bounds spec.
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_rhs_lbs(p, x)
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from rhs if no bounds spec.
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_rhs_lbs(p, x)
|
||||
real, target :: x(7:)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[c7_idx:.*]] = fir.convert %c7{{.*}} : (i64) -> index
|
||||
|
|
@ -148,41 +148,41 @@ subroutine test_scalar(p, x)
|
|||
|
||||
! CHECK: fir.store %[[rebox]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs2(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<200xf32>> {{{.*}}, fir.target}) {
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 200 : index
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 10 : i64
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 3 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 160 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.slice %[[VAL_4]], %[[VAL_8]], %[[VAL_6]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.embox %[[VAL_1]](%[[VAL_9]]) {{\[}}%[[VAL_10]]] : (!fir.ref<!fir.array<200xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.rebox %[[VAL_11]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_12]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs2(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<200xf32>> {{{.*}}, fir.target}) {
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 200 : index
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 10 : i64
|
||||
! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 3 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 160 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.slice %[[VAL_4]], %[[VAL_8]], %[[VAL_6]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.embox %[[VAL_1]](%[[VAL_9]]) {{\[}}%[[VAL_10]]] : (!fir.ref<!fir.array<200xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.rebox %[[VAL_11]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_12]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine test_array_non_contig_rhs2(p, x)
|
||||
subroutine test_array_non_contig_rhs2(p, x)
|
||||
real, target :: x(200)
|
||||
real, pointer :: p(:)
|
||||
p => x(10:160:3)
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test pointer assignments with bound specs to non contiguous right-hand side
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test pointer assignments with bound specs to non contiguous right-hand side
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from bound spec if specified
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs_new_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_rhs_new_lbs(p, x)
|
||||
! Test 10.2.2.3 point 10: lower bounds requirements:
|
||||
! pointer takes lbounds from bound spec if specified
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_rhs_new_lbs(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_rhs_new_lbs(p, x)
|
||||
real, target :: x(7:)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[shift:.*]] = fir.shift %c4{{.*}}
|
||||
|
|
@ -190,12 +190,12 @@ subroutine test_scalar(p, x)
|
|||
|
||||
! CHECK: fir.store %[[rebox]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p(4:) => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! Test F2018 10.2.2.3 point 9: bounds remapping
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_remap(p, x)
|
||||
! Test F2018 10.2.2.3 point 9: bounds remapping
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>{{.*}}, %[[x:.*]]: !fir.box<!fir.array<?xf32>> {{{.*}}, fir.target})
|
||||
subroutine test_array_non_contig_remap(p, x)
|
||||
real, target :: x(:)
|
||||
real, pointer :: p(:, :)
|
||||
! CHECK: subi
|
||||
|
|
@ -206,56 +206,56 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[rebox:.*]] = fir.rebox %[[x]](%[[shape]]) : (!fir.box<!fir.array<?xf32>>, !fir.shapeshift<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[rebox]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
p(2:11, 3:12) => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! Test remapping a slice
|
||||
! Test remapping a slice
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_remap_slice(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<400xf32>> {{{.*}}, fir.target}) {
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 400 : index
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 11 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 3 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 12 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 51 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 3 : i64
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 350 : i64
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_14:.*]] = fir.slice %[[VAL_8]], %[[VAL_12]], %[[VAL_10]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_1]](%[[VAL_13]]) {{\[}}%[[VAL_14]]] : (!fir.ref<!fir.array<400xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
|
||||
! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_18]], %[[VAL_17]] : index
|
||||
! CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_19]], %[[VAL_16]] : index
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
|
||||
! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_22]], %[[VAL_21]] : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_23]], %[[VAL_16]] : index
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
|
||||
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_27:.*]] = fir.shape_shift %[[VAL_25]], %[[VAL_20]], %[[VAL_26]], %[[VAL_24]] : (index, index, index, index) -> !fir.shapeshift<2>
|
||||
! CHECK: %[[VAL_28:.*]] = fir.rebox %[[VAL_15]](%[[VAL_27]]) : (!fir.box<!fir.array<?xf32>>, !fir.shapeshift<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_28]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
subroutine test_array_non_contig_remap_slice(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_array_non_contig_remap_slice(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<400xf32>> {{{.*}}, fir.target}) {
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 400 : index
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 11 : i64
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 3 : i64
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 12 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 51 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 3 : i64
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 350 : i64
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_14:.*]] = fir.slice %[[VAL_8]], %[[VAL_12]], %[[VAL_10]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_1]](%[[VAL_13]]) {{\[}}%[[VAL_14]]] : (!fir.ref<!fir.array<400xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
|
||||
! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_18]], %[[VAL_17]] : index
|
||||
! CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_19]], %[[VAL_16]] : index
|
||||
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
|
||||
! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_22]], %[[VAL_21]] : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_23]], %[[VAL_16]] : index
|
||||
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
|
||||
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
|
||||
! CHECK: %[[VAL_27:.*]] = fir.shape_shift %[[VAL_25]], %[[VAL_20]], %[[VAL_26]], %[[VAL_24]] : (index, index, index, index) -> !fir.shapeshift<2>
|
||||
! CHECK: %[[VAL_28:.*]] = fir.rebox %[[VAL_15]](%[[VAL_27]]) : (!fir.box<!fir.array<?xf32>>, !fir.shapeshift<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_28]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
subroutine test_array_non_contig_remap_slice(p, x)
|
||||
real, target :: x(400)
|
||||
real, pointer :: p(:, :)
|
||||
p(2:11, 3:12) => x(51:350:3)
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test pointer assignments that involves LHS pointers lowered to local variables
|
||||
! instead of a fir.ref<fir.box>, and RHS that are fir.box
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test pointer assignments that involves LHS pointers lowered to local variables
|
||||
! instead of a fir.ref<fir.box>, and RHS that are fir.box
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QPissue857(
|
||||
! CHECK-SAME: %[[rhs:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFissue857Tt{i:i32}>>>>
|
||||
subroutine issue857(rhs)
|
||||
! CHECK-LABEL: func @_QPissue857(
|
||||
! CHECK-SAME: %[[rhs:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFissue857Tt{i:i32}>>>>
|
||||
subroutine issue857(rhs)
|
||||
type t
|
||||
integer :: i
|
||||
end type
|
||||
|
|
@ -265,11 +265,11 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.ptr<!fir.type<_QFissue857Tt{i:i32}>>>) -> !fir.ptr<!fir.type<_QFissue857Tt{i:i32}>>
|
||||
! CHECK: fir.store %[[addr]] to %[[lhs]] : !fir.ref<!fir.ptr<!fir.type<_QFissue857Tt{i:i32}>>>
|
||||
lhs => rhs
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue857_array(
|
||||
! CHECK-SAME: %[[rhs:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFissue857_arrayTt{i:i32}>>>>>
|
||||
subroutine issue857_array(rhs)
|
||||
! CHECK-LABEL: func @_QPissue857_array(
|
||||
! CHECK-SAME: %[[rhs:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFissue857_arrayTt{i:i32}>>>>>
|
||||
subroutine issue857_array(rhs)
|
||||
type t
|
||||
integer :: i
|
||||
end type
|
||||
|
|
@ -285,10 +285,10 @@ subroutine test_scalar(p, x)
|
|||
! CHECK-DAG: fir.store %[[ext]]#1 to %[[lhs_ext]] : !fir.ref<index>
|
||||
! CHECK-DAG: fir.store %[[lb]]#0 to %[[lhs_lb]] : !fir.ref<index>
|
||||
lhs => rhs
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue857_array_shift(
|
||||
subroutine issue857_array_shift(rhs)
|
||||
! CHECK-LABEL: func @_QPissue857_array_shift(
|
||||
subroutine issue857_array_shift(rhs)
|
||||
! Test lower bounds is the one from the shift
|
||||
type t
|
||||
integer :: i
|
||||
|
|
@ -298,10 +298,10 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[c42:.*]] = fir.convert %c42{{.*}} : (i64) -> index
|
||||
! CHECK: fir.store %[[c42]] to %[[lhs_lb]] : !fir.ref<index>
|
||||
lhs(42:) => rhs
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue857_array_remap
|
||||
subroutine issue857_array_remap(rhs)
|
||||
! CHECK-LABEL: func @_QPissue857_array_remap
|
||||
subroutine issue857_array_remap(rhs)
|
||||
! Test lower bounds is the one from the shift
|
||||
type t
|
||||
integer :: i
|
||||
|
|
@ -322,10 +322,10 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[c101_2:.*]] = fir.convert %c101{{.*}} : (i64) -> index
|
||||
! CHECK: fir.store %[[c101_2]] to %[[lhs_lb]] : !fir.ref<index>
|
||||
lhs(101:200) => rhs
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue857_char
|
||||
subroutine issue857_char(rhs)
|
||||
! CHECK-LABEL: func @_QPissue857_char
|
||||
subroutine issue857_char(rhs)
|
||||
! Only check that the length is taken from the fir.box created for the slice.
|
||||
! CHECK-DAG: %[[lhs1_len:.*]] = fir.alloca index {uniq_name = "_QFissue857_charElhs1.len"}
|
||||
! CHECK-DAG: %[[lhs2_len:.*]] = fir.alloca index {uniq_name = "_QFissue857_charElhs2.len"}
|
||||
|
|
@ -337,11 +337,11 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[len2:.*]] = fir.box_elesize %{{.*}} : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
|
||||
! CHECK: fir.store %[[len2]] to %[[lhs2_len]] : !fir.ref<index>
|
||||
lhs2(1:2, 1:25) => rhs(1:50:1)
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPissue1180(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {{{.*}}, fir.target}) {
|
||||
subroutine issue1180(x)
|
||||
! CHECK-LABEL: func @_QPissue1180(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {{{.*}}, fir.target}) {
|
||||
subroutine issue1180(x)
|
||||
integer, target :: x
|
||||
integer, pointer :: p
|
||||
common /some_common/ p
|
||||
|
|
@ -353,4 +353,4 @@ subroutine test_scalar(p, x)
|
|||
! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<i32>) -> !fir.box<!fir.ptr<i32>>
|
||||
! CHECK: fir.store %[[VAL_6]] to %[[VAL_5]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
p => x
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
|
|
|||
|
|
@ -15,48 +15,48 @@ subroutine test_scalar(p)
|
|||
! CHECK: %[[box:.*]] = fir.embox %[[null]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
p => NULL()
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}})
|
||||
subroutine test_scalar_char(p)
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{.*}})
|
||||
subroutine test_scalar_char(p)
|
||||
character(:), pointer :: p
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.char<1,?>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]] typeparams %c0{{.*}} : (!fir.ptr<!fir.char<1,?>>, index) -> !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
p => NULL()
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_array(p)
|
||||
! CHECK-LABEL: func @_QPtest_array(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_array(p)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c0{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p => NULL()
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! Test p(lb, ub) => NULL() which is none sens but is not illegal.
|
||||
! CHECK-LABEL: func @_QPtest_array_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_array_remap(p)
|
||||
! Test p(lb, ub) => NULL() which is none sens but is not illegal.
|
||||
! CHECK-LABEL: func @_QPtest_array_remap(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine test_array_remap(p)
|
||||
real, pointer :: p(:)
|
||||
! CHECK: %[[null:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c0{{.*}}
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[null]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[box]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p(10:20) => NULL()
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test p => NULL(MOLD)
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test p => NULL(MOLD)
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_mold(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{[^,]*}},
|
||||
subroutine test_scalar_mold(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_scalar_mold(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{[^,]*}},
|
||||
subroutine test_scalar_mold(p, x)
|
||||
real, pointer :: p, x
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[VAL_1:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
|
|
@ -67,11 +67,11 @@ subroutine test_scalar(p)
|
|||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_4]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[VAL_5]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
p => NULL(x)
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char_mold(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{[^,]*}},
|
||||
subroutine test_scalar_char_mold(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_scalar_char_mold(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>{{[^,]*}},
|
||||
subroutine test_scalar_char_mold(p, x)
|
||||
character(:), pointer :: p, x
|
||||
! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.zero_bits !fir.ptr<!fir.char<1,?>>
|
||||
|
|
@ -84,11 +84,11 @@ subroutine test_scalar(p)
|
|||
! CHECK: %[[VAL_14:.*]] = fir.embox %[[VAL_13]] typeparams %[[VAL_12]] : (!fir.ptr<!fir.char<1,?>>, index) -> !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: fir.store %[[VAL_14]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.char<1,?>>>>
|
||||
p => NULL(x)
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPtest_array_mold(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{[^,]*}},
|
||||
subroutine test_array_mold(p, x)
|
||||
! CHECK-LABEL: func @_QPtest_array_mold(
|
||||
! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{[^,]*}},
|
||||
subroutine test_array_mold(p, x)
|
||||
real, pointer :: p(:), x(:)
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: %[[VAL_1:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
|
|
@ -103,4 +103,4 @@ subroutine test_scalar(p)
|
|||
! CHECK: %[[VAL_9:.*]] = fir.rebox %[[VAL_5]](%[[VAL_8]]) : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_9]] to %[[p]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
p => NULL(x)
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
|
|
|||
|
|
@ -9,20 +9,20 @@
|
|||
module some_mod
|
||||
real, target :: x(100)
|
||||
real, pointer :: p(:) => x
|
||||
! CHECK-LABEL: fir.global @_QMsome_modEp : !fir.box<!fir.ptr<!fir.array<?xf32>>> {
|
||||
! CHECK-LABEL: fir.global @_QMsome_modEp : !fir.box<!fir.ptr<!fir.array<?xf32>>> {
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QMsome_modEx) : !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c100{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]](%[[shape]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
end module
|
||||
end module
|
||||
|
||||
! Test initial data target in a common block
|
||||
module some_mod_2
|
||||
! Test initial data target in a common block
|
||||
module some_mod_2
|
||||
real, target :: x(100), y(10:209)
|
||||
common /com/ x, y
|
||||
save :: /com/
|
||||
real, pointer :: p(:) => y
|
||||
! CHECK-LABEL: fir.global @_QMsome_mod_2Ep : !fir.box<!fir.ptr<!fir.array<?xf32>>> {
|
||||
! CHECK-LABEL: fir.global @_QMsome_mod_2Ep : !fir.box<!fir.ptr<!fir.array<?xf32>>> {
|
||||
! CHECK: %[[c:.*]] = fir.address_of(@_QBcom) : !fir.ref<!fir.array<1200xi8>>
|
||||
! CHECK: %[[com:.*]] = fir.convert %[[c]] : (!fir.ref<!fir.array<1200xi8>>) -> !fir.ref<!fir.array<?xi8>>
|
||||
! CHECK: %[[yRaw:.*]] = fir.coordinate_of %[[com]], %c400{{.*}} : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>
|
||||
|
|
@ -30,28 +30,28 @@ module some_mod
|
|||
! CHECK: %[[shape:.*]] = fir.shape_shift %c10{{.*}}, %c200{{.*}} : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[y]](%[[shape]]) : (!fir.ref<!fir.array<200xf32>>, !fir.shapeshift<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
end module
|
||||
end module
|
||||
|
||||
! Test pointer initial data target with pointer in common blocks
|
||||
block data
|
||||
! Test pointer initial data target with pointer in common blocks
|
||||
block data
|
||||
real, pointer :: p
|
||||
real, save, target :: b
|
||||
common /a/ p
|
||||
data p /b/
|
||||
! CHECK-LABEL: fir.global @_QBa : tuple<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK-LABEL: fir.global @_QBa : tuple<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: %[[undef:.*]] = fir.undefined tuple<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: %[[b:.*]] = fir.address_of(@_QEb) : !fir.ref<f32>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[b]] : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[a:.*]] = fir.insert_value %[[undef]], %[[box]], [0 : index] : (tuple<!fir.box<!fir.ptr<f32>>>, !fir.box<!fir.ptr<f32>>) -> tuple<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.has_value %[[a]] : tuple<!fir.box<!fir.ptr<f32>>>
|
||||
end block data
|
||||
end block data
|
||||
|
||||
! Test pointer in a common with initial target in the same common.
|
||||
block data snake
|
||||
! Test pointer in a common with initial target in the same common.
|
||||
block data snake
|
||||
integer, target :: b = 42
|
||||
integer, pointer :: p => b
|
||||
common /snake/ p, b
|
||||
! CHECK-LABEL: fir.global @_QBsnake : tuple<!fir.box<!fir.ptr<i32>>, i32>
|
||||
! CHECK-LABEL: fir.global @_QBsnake : tuple<!fir.box<!fir.ptr<i32>>, i32>
|
||||
! CHECK: %[[tuple0:.*]] = fir.undefined tuple<!fir.box<!fir.ptr<i32>>, i32>
|
||||
! CHECK: %[[snakeAddr:.*]] = fir.address_of(@_QBsnake) : !fir.ref<tuple<!fir.box<!fir.ptr<i32>>, i32>>
|
||||
! CHECK: %[[byteView:.*]] = fir.convert %[[snakeAddr:.*]] : (!fir.ref<tuple<!fir.box<!fir.ptr<i32>>, i32>>) -> !fir.ref<!fir.array<?xi8>>
|
||||
|
|
@ -61,19 +61,19 @@ module some_mod
|
|||
! CHECK: %[[tuple1:.*]] = fir.insert_value %[[tuple0]], %[[box]], [0 : index] : (tuple<!fir.box<!fir.ptr<i32>>, i32>, !fir.box<!fir.ptr<i32>>) -> tuple<!fir.box<!fir.ptr<i32>>, i32>
|
||||
! CHECK: %[[tuple2:.*]] = fir.insert_value %[[tuple1]], %c42{{.*}}, [1 : index] : (tuple<!fir.box<!fir.ptr<i32>>, i32>, i32) -> tuple<!fir.box<!fir.ptr<i32>>, i32>
|
||||
! CHECK: fir.has_value %[[tuple2]] : tuple<!fir.box<!fir.ptr<i32>>, i32>
|
||||
end block data
|
||||
end block data
|
||||
|
||||
! Test two common depending on each others because of initial data
|
||||
! targets
|
||||
block data tied
|
||||
! Test two common depending on each others because of initial data
|
||||
! targets
|
||||
block data tied
|
||||
real, target :: x1 = 42
|
||||
real, target :: x2 = 43
|
||||
real, pointer :: p1 => x2
|
||||
real, pointer :: p2 => x1
|
||||
common /c1/ x1, p1
|
||||
common /c2/ x2, p2
|
||||
! CHECK-LABEL: fir.global @_QBc1 : tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>
|
||||
! CHECK-LABEL: fir.global @_QBc1 : tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.address_of(@_QBc2) : !fir.ref<tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>>
|
||||
! CHECK-LABEL: fir.global @_QBc2 : tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>
|
||||
! CHECK-LABEL: fir.global @_QBc2 : tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.address_of(@_QBc1) : !fir.ref<tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>>
|
||||
end block data
|
||||
end block data
|
||||
|
|
|
|||
|
|
@ -8,130 +8,130 @@
|
|||
subroutine scalar()
|
||||
real, save, target :: x
|
||||
real, pointer :: p => x
|
||||
! CHECK-LABEL: fir.global internal @_QFscalarEp : !fir.box<!fir.ptr<f32>>
|
||||
! CHECK-LABEL: fir.global internal @_QFscalarEp : !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFscalarEx) : !fir.ref<f32>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]] : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<f32>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine scalar_char()
|
||||
subroutine scalar_char()
|
||||
character(10), save, target :: x
|
||||
character(:), pointer :: p => x
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_charEp : !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_charEp : !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFscalar_charEx) : !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[xCast:.*]] = fir.convert %[[x]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ptr<!fir.char<1,?>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[xCast]] typeparams %c10{{.*}} : (!fir.ptr<!fir.char<1,?>>, index) -> !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.char<1,?>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine scalar_char_2()
|
||||
subroutine scalar_char_2()
|
||||
character(10), save, target :: x
|
||||
character(10), pointer :: p => x
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_char_2Ep : !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_char_2Ep : !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFscalar_char_2Ex) : !fir.ref<!fir.char<1,10>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]] : (!fir.ref<!fir.char<1,10>>) -> !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine scalar_derived()
|
||||
subroutine scalar_derived()
|
||||
type t
|
||||
real :: x
|
||||
integer :: i
|
||||
end type
|
||||
type(t), save, target :: x
|
||||
type(t), pointer :: p => x
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_derivedEp : !fir.box<!fir.ptr<!fir.type<_QFscalar_derivedTt{x:f32,i:i32}>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_derivedEp : !fir.box<!fir.ptr<!fir.type<_QFscalar_derivedTt{x:f32,i:i32}>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFscalar_derivedEx) : !fir.ref<!fir.type<_QFscalar_derivedTt{x:f32,i:i32}>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]] : (!fir.ref<!fir.type<_QFscalar_derivedTt{x:f32,i:i32}>>) -> !fir.box<!fir.ptr<!fir.type<_QFscalar_derivedTt{x:f32,i:i32}>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.type<_QFscalar_derivedTt{x:f32,i:i32}>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine scalar_null()
|
||||
subroutine scalar_null()
|
||||
real, pointer :: p => NULL()
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_nullEp : !fir.box<!fir.ptr<f32>>
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_nullEp : !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[zero:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[zero]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<f32>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test array initial data target that are simple names
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test array initial data target that are simple names
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
subroutine array()
|
||||
subroutine array()
|
||||
real, save, target :: x(100)
|
||||
real, pointer :: p(:) => x
|
||||
! CHECK-LABEL: fir.global internal @_QFarrayEp : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFarrayEp : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFarrayEx) : !fir.ref<!fir.array<100xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c100{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]](%[[shape]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine array_char()
|
||||
subroutine array_char()
|
||||
character(10), save, target :: x(20)
|
||||
character(:), pointer :: p(:) => x
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_charEp : !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_charEp : !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFarray_charEx) : !fir.ref<!fir.array<20x!fir.char<1,10>>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c20{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[xCast:.*]] = fir.convert %[[x]] : (!fir.ref<!fir.array<20x!fir.char<1,10>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[xCast]](%[[shape]]) typeparams %c10{{.*}} : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine array_char_2()
|
||||
subroutine array_char_2()
|
||||
character(10), save, target :: x(20)
|
||||
character(10), pointer :: p(:) => x
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_char_2Ep : !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_char_2Ep : !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFarray_char_2Ex) : !fir.ref<!fir.array<20x!fir.char<1,10>>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c20{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]](%[[shape]]) : (!fir.ref<!fir.array<20x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine array_derived()
|
||||
subroutine array_derived()
|
||||
type t
|
||||
real :: x
|
||||
integer :: i
|
||||
end type
|
||||
type(t), save, target :: x(100)
|
||||
type(t), pointer :: p(:) => x
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_derivedEp : !fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFarray_derivedTt{x:f32,i:i32}>>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_derivedEp : !fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFarray_derivedTt{x:f32,i:i32}>>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFarray_derivedEx) : !fir.ref<!fir.array<100x!fir.type<_QFarray_derivedTt{x:f32,i:i32}>>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c100{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[x]](%[[shape]]) : (!fir.ref<!fir.array<100x!fir.type<_QFarray_derivedTt{x:f32,i:i32}>>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFarray_derivedTt{x:f32,i:i32}>>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFarray_derivedTt{x:f32,i:i32}>>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine array_null()
|
||||
subroutine array_null()
|
||||
real, pointer :: p(:) => NULL()
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_nullEp : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_nullEp : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: %[[zero:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[shape:.*]] = fir.shape %c0{{.*}} : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[zero]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test scalar initial data target that are data references
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test scalar initial data target that are data references
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
subroutine scalar_ref()
|
||||
subroutine scalar_ref()
|
||||
real, save, target :: x(4:100)
|
||||
real, pointer :: p => x(50)
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_refEp : !fir.box<!fir.ptr<f32>> {
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_refEp : !fir.box<!fir.ptr<f32>> {
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFscalar_refEx) : !fir.ref<!fir.array<97xf32>>
|
||||
! CHECK: %[[lb:.*]] = fir.convert %c4 : (index) -> i64
|
||||
! CHECK: %[[idx:.*]] = arith.subi %c50{{.*}}, %[[lb]] : i64
|
||||
! CHECK: %[[elt:.*]] = fir.coordinate_of %[[x]], %[[idx]] : (!fir.ref<!fir.array<97xf32>>, i64) -> !fir.ref<f32>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[elt]] : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<f32>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
subroutine scalar_char_ref()
|
||||
subroutine scalar_char_ref()
|
||||
character(20), save, target :: x(100)
|
||||
character(10), pointer :: p => x(6)(7:16)
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_char_refEp : !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
! CHECK-LABEL: fir.global internal @_QFscalar_char_refEp : !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
! CHECK: %[[x:.*]] = fir.address_of(@_QFscalar_char_refEx) : !fir.ref<!fir.array<100x!fir.char<1,20>>>
|
||||
! CHECK: %[[idx:.*]] = arith.subi %c6{{.*}}, %c1{{.*}} : i64
|
||||
! CHECK: %[[elt:.*]] = fir.coordinate_of %[[x]], %[[idx]] : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, i64) -> !fir.ref<!fir.char<1,20>>
|
||||
|
|
@ -141,46 +141,45 @@ subroutine scalar()
|
|||
! CHECK: %[[substringCast:.*]] = fir.convert %[[substring]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ptr<!fir.char<1,10>>
|
||||
! CHECK: %[[box:.*]] = fir.embox %[[substringCast]] : (!fir.ptr<!fir.char<1,10>>) -> !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
! CHECK: fir.has_value %[[box]] : !fir.box<!fir.ptr<!fir.char<1,10>>>
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test array initial data target that are data references
|
||||
! -----------------------------------------------------------------------------
|
||||
! -----------------------------------------------------------------------------
|
||||
! Test array initial data target that are data references
|
||||
! -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
subroutine array_ref()
|
||||
subroutine array_ref()
|
||||
real, save, target :: x(4:103, 5:104)
|
||||
real, pointer :: p(:) => x(10, 20:100:2)
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_refEp : !fir.box<!fir.ptr<!fir.array<?xf32>>> {
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QFarray_refEx) : !fir.ref<!fir.array<100x100xf32>>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 4 : index
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 5 : index
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 10 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.undefined index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_9]], %[[VAL_1]] : index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 20 : i64
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.constant 100 : i64
|
||||
! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i64) -> index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_18:.*]] = arith.subi %[[VAL_16]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_19:.*]] = arith.addi %[[VAL_18]], %[[VAL_14]] : index
|
||||
! CHECK: %[[VAL_20:.*]] = arith.divsi %[[VAL_19]], %[[VAL_14]] : index
|
||||
! CHECK: %[[VAL_21:.*]] = arith.cmpi sgt, %[[VAL_20]], %[[VAL_17]] : index
|
||||
! CHECK: %[[VAL_22:.*]] = arith.select %[[VAL_21]], %[[VAL_20]], %[[VAL_17]] : index
|
||||
! CHECK: %[[VAL_23:.*]] = fir.shape_shift %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]] : (index, index, index, index) -> !fir.shapeshift<2>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.slice %[[VAL_7]], %[[VAL_8]], %[[VAL_8]], %[[VAL_12]], %[[VAL_16]], %[[VAL_14]] : (i64, index, index, index, index, index) -> !fir.slice<2>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.embox %[[VAL_0]](%[[VAL_23]]) {{\[}}%[[VAL_24]]] : (!fir.ref<!fir.array<100x100xf32>>, !fir.shapeshift<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.embox %[[VAL_0]](%[[VAL_23]]) {{\[}}%[[VAL_24]]] : (!fir.ref<!fir.array<100x100xf32>>, !fir.shapeshift<2>, !fir.slice<2>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.has_value %[[VAL_26]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: }
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: fir.global internal @_QFarray_refEp : !fir.box<!fir.ptr<!fir.array<?xf32>>> {
|
||||
! CHECK: %[[VAL_0:.*]] = fir.address_of(@_QFarray_refEx) : !fir.ref<!fir.array<100x100xf32>>
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 4 : index
|
||||
! CHECK: %[[VAL_2:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_3:.*]] = arith.constant 5 : index
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 10 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.undefined index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_9]], %[[VAL_1]] : index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 20 : i64
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.constant 100 : i64
|
||||
! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i64) -> index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_18:.*]] = arith.subi %[[VAL_16]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_19:.*]] = arith.addi %[[VAL_18]], %[[VAL_14]] : index
|
||||
! CHECK: %[[VAL_20:.*]] = arith.divsi %[[VAL_19]], %[[VAL_14]] : index
|
||||
! CHECK: %[[VAL_21:.*]] = arith.cmpi sgt, %[[VAL_20]], %[[VAL_17]] : index
|
||||
! CHECK: %[[VAL_22:.*]] = arith.select %[[VAL_21]], %[[VAL_20]], %[[VAL_17]] : index
|
||||
! CHECK: %[[VAL_23:.*]] = fir.shape_shift %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]] : (index, index, index, index) -> !fir.shapeshift<2>
|
||||
! CHECK: %[[VAL_24:.*]] = fir.slice %[[VAL_7]], %[[VAL_8]], %[[VAL_8]], %[[VAL_12]], %[[VAL_16]], %[[VAL_14]] : (i64, index, index, index, index, index) -> !fir.slice<2>
|
||||
! CHECK: %[[VAL_25:.*]] = fir.embox %[[VAL_0]](%[[VAL_23]]) {{\[}}%[[VAL_24]]] : (!fir.ref<!fir.array<100x100xf32>>, !fir.shapeshift<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_26:.*]] = fir.embox %[[VAL_0]](%[[VAL_23]]) {{\[}}%[[VAL_24]]] : (!fir.ref<!fir.array<100x100xf32>>, !fir.shapeshift<2>, !fir.slice<2>) -> !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: fir.has_value %[[VAL_26]] : !fir.box<!fir.ptr<!fir.array<?xf32>>>
|
||||
! CHECK: }
|
||||
|
|
|
|||
|
|
@ -1,180 +0,0 @@
|
|||
! Test lowering of references to pointers
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! Assigning/reading to scalar pointer target.
|
||||
! CHECK-LABEL: func @_QPscal_ptr(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{.*}})
|
||||
subroutine scal_ptr(p)
|
||||
real, pointer :: p
|
||||
real :: x
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[boxload]]
|
||||
! CHECK: fir.store %{{.*}} to %[[addr]]
|
||||
p = 3.
|
||||
|
||||
! CHECK: %[[boxload2:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr2:.*]] = fir.box_addr %[[boxload2]]
|
||||
! CHECK: %[[val:.*]] = fir.load %[[addr2]]
|
||||
! CHECK: fir.store %[[val]] to %{{.*}}
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Assigning/reading scalar character pointer target.
|
||||
! CHECK-LABEL: func @_QPchar_ptr(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,12>>>>{{.*}})
|
||||
subroutine char_ptr(p)
|
||||
character(12), pointer :: p
|
||||
character(12) :: x
|
||||
|
||||
! CHECK-DAG: %[[str:.*]] = fir.address_of(@_QQcl.68656C6C6F20776F726C6421) : !fir.ref<!fir.char<1,12>>
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[boxload]]
|
||||
! CHECK-DAG: %[[one:.*]] = arith.constant 1
|
||||
! CHECK-DAG: %[[size:.*]] = fir.convert %{{.*}} : (index) -> i64
|
||||
! CHECK: %[[count:.*]] = arith.muli %[[one]], %[[size]] : i64
|
||||
! CHECK: %[[dst:.*]] = fir.convert %[[addr]] : (!fir.ptr<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[src:.*]] = fir.convert %[[str]] : (!fir.ref<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[dst]], %[[src]], %5, %false) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
p = "hello world!"
|
||||
|
||||
! CHECK: %[[boxload2:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr2:.*]] = fir.box_addr %[[boxload2]]
|
||||
! CHECK: %[[count:.*]] = arith.muli %{{.*}}, %{{.*}} : i64
|
||||
! CHECK: %[[dst:.*]] = fir.convert %{{.*}} : (!fir.ref<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[src:.*]] = fir.convert %[[addr2]] : (!fir.ptr<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[dst]], %[[src]], %[[count]], %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Reading from pointer in array expression
|
||||
! CHECK-LABEL: func @_QParr_ptr_read(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine arr_ptr_read(p)
|
||||
real, pointer :: p(:)
|
||||
real :: x(100)
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[dims:.*]]:3 = fir.box_dims %[[boxload]], %c0{{.*}} : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[lb:.*]] = fir.shift %[[dims]]#0 : (index) -> !fir.shift<1>
|
||||
! CHECK: fir.array_load %[[boxload]](%[[lb]]) : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.array<?xf32>
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Reading from contiguous pointer in array expression
|
||||
! CHECK-LABEL: func @_QParr_contig_ptr_read(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {{{.*}}, fir.contiguous})
|
||||
subroutine arr_contig_ptr_read(p)
|
||||
real, pointer, contiguous :: p(:)
|
||||
real :: x(100)
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[boxload]], %c0{{.*}} : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[boxload]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK-DAG: %[[shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: fir.array_load %[[addr]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shapeshift<1>) -> !fir.array<?xf32>
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Assigning to pointer target in array expression
|
||||
|
||||
! CHECK-LABEL: func @_QParr_ptr_target_write(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}) {
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<100xf32> {bindc_name = "x", uniq_name = "_QFarr_ptr_target_writeEx"}
|
||||
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_4]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 6 : i64
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i64) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 601 : i64
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i64) -> index
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.subi %[[VAL_11]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_9]] : index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.divsi %[[VAL_14]], %[[VAL_9]] : index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_16]], %[[VAL_15]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.shift %[[VAL_5]]#0 : (index) -> !fir.shift<1>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.slice %[[VAL_7]], %[[VAL_11]], %[[VAL_9]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.array_load %[[VAL_3]](%[[VAL_18]]) {{\[}}%[[VAL_19]]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>, !fir.slice<1>) -> !fir.array<?xf32>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.array_load %[[VAL_2]](%[[VAL_21]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
|
||||
! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_17]], %[[VAL_23]] : index
|
||||
! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_20]]) -> (!fir.array<?xf32>) {
|
||||
! CHECK: %[[VAL_29:.*]] = fir.array_fetch %[[VAL_22]], %[[VAL_27]] : (!fir.array<100xf32>, index) -> f32
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_update %[[VAL_28]], %[[VAL_29]], %[[VAL_27]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
|
||||
! CHECK: fir.result %[[VAL_30]] : !fir.array<?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_20]], %[[VAL_31:.*]] to %[[VAL_3]]{{\[}}%[[VAL_19]]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.slice<1>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine arr_ptr_target_write(p)
|
||||
real, pointer :: p(:)
|
||||
real :: x(100)
|
||||
p(2:601:6) = x
|
||||
end subroutine
|
||||
|
||||
! Assigning to contiguous pointer target in array expression
|
||||
|
||||
! CHECK-LABEL: func @_QParr_contig_ptr_target_write(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {{{.*}}, fir.contiguous}) {
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<100xf32> {bindc_name = "x", uniq_name = "_QFarr_contig_ptr_target_writeEx"}
|
||||
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_4]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_6:.*]] = fir.box_addr %[[VAL_3]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 6 : i64
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 601 : i64
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_8]] : index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_10]] : index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.divsi %[[VAL_15]], %[[VAL_10]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.cmpi sgt, %[[VAL_16]], %[[VAL_13]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_16]], %[[VAL_13]] : index
|
||||
! CHECK: %[[VAL_19:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.slice %[[VAL_8]], %[[VAL_12]], %[[VAL_10]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_6]](%[[VAL_19]]) {{\[}}%[[VAL_20]]] : (!fir.ptr<!fir.array<?xf32>>, !fir.shapeshift<1>, !fir.slice<1>) -> !fir.array<?xf32>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.array_load %[[VAL_2]](%[[VAL_22]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_18]], %[[VAL_24]] : index
|
||||
! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_26]] step %[[VAL_24]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_21]]) -> (!fir.array<?xf32>) {
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_28]] : (!fir.array<100xf32>, index) -> f32
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_update %[[VAL_29]], %[[VAL_30]], %[[VAL_28]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
|
||||
! CHECK: fir.result %[[VAL_31]] : !fir.array<?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_21]], %[[VAL_32:.*]] to %[[VAL_6]]{{\[}}%[[VAL_20]]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ptr<!fir.array<?xf32>>, !fir.slice<1>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine arr_contig_ptr_target_write(p)
|
||||
real, pointer, contiguous :: p(:)
|
||||
real :: x(100)
|
||||
p(2:601:6) = x
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPpointer_result_as_value
|
||||
subroutine pointer_result_as_value()
|
||||
! Test that function pointer results used as values are correctly loaded.
|
||||
interface
|
||||
function returns_int_pointer()
|
||||
integer, pointer :: returns_int_pointer
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<i32>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_6:.*]] = fir.call @_QPreturns_int_pointer() : () -> !fir.box<!fir.ptr<i32>>
|
||||
! CHECK: fir.save_result %[[VAL_6]] to %[[VAL_0]] : !fir.box<!fir.ptr<i32>>, !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
|
||||
! CHECK: fir.load %[[VAL_8]] : !fir.ptr<i32>
|
||||
print *, returns_int_pointer()
|
||||
end subroutine
|
||||
|
|
@ -0,0 +1,180 @@
|
|||
! Test lowering of references to pointers
|
||||
! RUN: bbc -emit-fir %s -o - | FileCheck %s
|
||||
|
||||
! Assigning/reading to scalar pointer target.
|
||||
! CHECK-LABEL: func @_QPscal_ptr(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>{{.*}})
|
||||
subroutine scal_ptr(p)
|
||||
real, pointer :: p
|
||||
real :: x
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[boxload]]
|
||||
! CHECK: fir.store %{{.*}} to %[[addr]]
|
||||
p = 3.
|
||||
|
||||
! CHECK: %[[boxload2:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr2:.*]] = fir.box_addr %[[boxload2]]
|
||||
! CHECK: %[[val:.*]] = fir.load %[[addr2]]
|
||||
! CHECK: fir.store %[[val]] to %{{.*}}
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Assigning/reading scalar character pointer target.
|
||||
! CHECK-LABEL: func @_QPchar_ptr(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.char<1,12>>>>{{.*}})
|
||||
subroutine char_ptr(p)
|
||||
character(12), pointer :: p
|
||||
character(12) :: x
|
||||
|
||||
! CHECK-DAG: %[[str:.*]] = fir.address_of(@_QQcl.68656C6C6F20776F726C6421) : !fir.ref<!fir.char<1,12>>
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr:.*]] = fir.box_addr %[[boxload]]
|
||||
! CHECK-DAG: %[[one:.*]] = arith.constant 1
|
||||
! CHECK-DAG: %[[size:.*]] = fir.convert %{{.*}} : (index) -> i64
|
||||
! CHECK: %[[count:.*]] = arith.muli %[[one]], %[[size]] : i64
|
||||
! CHECK: %[[dst:.*]] = fir.convert %[[addr]] : (!fir.ptr<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[src:.*]] = fir.convert %[[str]] : (!fir.ref<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[dst]], %[[src]], %5, %false) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
p = "hello world!"
|
||||
|
||||
! CHECK: %[[boxload2:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[addr2:.*]] = fir.box_addr %[[boxload2]]
|
||||
! CHECK: %[[count:.*]] = arith.muli %{{.*}}, %{{.*}} : i64
|
||||
! CHECK: %[[dst:.*]] = fir.convert %{{.*}} : (!fir.ref<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: %[[src:.*]] = fir.convert %[[addr2]] : (!fir.ptr<!fir.char<1,12>>) -> !fir.ref<i8>
|
||||
! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[dst]], %[[src]], %[[count]], %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Reading from pointer in array expression
|
||||
! CHECK-LABEL: func @_QParr_ptr_read(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}})
|
||||
subroutine arr_ptr_read(p)
|
||||
real, pointer :: p(:)
|
||||
real :: x(100)
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK: %[[dims:.*]]:3 = fir.box_dims %[[boxload]], %c0{{.*}} : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[lb:.*]] = fir.shift %[[dims]]#0 : (index) -> !fir.shift<1>
|
||||
! CHECK: fir.array_load %[[boxload]](%[[lb]]) : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.array<?xf32>
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Reading from contiguous pointer in array expression
|
||||
! CHECK-LABEL: func @_QParr_contig_ptr_read(
|
||||
! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {{{.*}}, fir.contiguous})
|
||||
subroutine arr_contig_ptr_read(p)
|
||||
real, pointer, contiguous :: p(:)
|
||||
real :: x(100)
|
||||
! CHECK: %[[boxload:.*]] = fir.load %[[arg0]]
|
||||
! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[boxload]], %c0{{.*}} : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK-DAG: %[[addr:.*]] = fir.box_addr %[[boxload]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK-DAG: %[[shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: fir.array_load %[[addr]](%[[shape]]) : (!fir.ptr<!fir.array<?xf32>>, !fir.shapeshift<1>) -> !fir.array<?xf32>
|
||||
x = p
|
||||
end subroutine
|
||||
|
||||
! Assigning to pointer target in array expression
|
||||
|
||||
! CHECK-LABEL: func @_QParr_ptr_target_write(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>{{.*}}) {
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<100xf32> {bindc_name = "x", uniq_name = "_QFarr_ptr_target_writeEx"}
|
||||
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_4]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_6:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 6 : i64
|
||||
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i64) -> index
|
||||
! CHECK: %[[VAL_10:.*]] = arith.constant 601 : i64
|
||||
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i64) -> index
|
||||
! CHECK: %[[VAL_12:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.subi %[[VAL_11]], %[[VAL_7]] : index
|
||||
! CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_9]] : index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.divsi %[[VAL_14]], %[[VAL_9]] : index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_16]], %[[VAL_15]], %[[VAL_12]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = fir.shift %[[VAL_5]]#0 : (index) -> !fir.shift<1>
|
||||
! CHECK: %[[VAL_19:.*]] = fir.slice %[[VAL_7]], %[[VAL_11]], %[[VAL_9]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.array_load %[[VAL_3]](%[[VAL_18]]) {{\[}}%[[VAL_19]]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>, !fir.slice<1>) -> !fir.array<?xf32>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.array_load %[[VAL_2]](%[[VAL_21]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
|
||||
! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_17]], %[[VAL_23]] : index
|
||||
! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_20]]) -> (!fir.array<?xf32>) {
|
||||
! CHECK: %[[VAL_29:.*]] = fir.array_fetch %[[VAL_22]], %[[VAL_27]] : (!fir.array<100xf32>, index) -> f32
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_update %[[VAL_28]], %[[VAL_29]], %[[VAL_27]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
|
||||
! CHECK: fir.result %[[VAL_30]] : !fir.array<?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_20]], %[[VAL_31:.*]] to %[[VAL_3]]{{\[}}%[[VAL_19]]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.slice<1>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine arr_ptr_target_write(p)
|
||||
real, pointer :: p(:)
|
||||
real :: x(100)
|
||||
p(2:601:6) = x
|
||||
end subroutine
|
||||
|
||||
! Assigning to contiguous pointer target in array expression
|
||||
|
||||
! CHECK-LABEL: func @_QParr_contig_ptr_target_write(
|
||||
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {{{.*}}, fir.contiguous}) {
|
||||
! CHECK: %[[VAL_1:.*]] = arith.constant 100 : index
|
||||
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<100xf32> {bindc_name = "x", uniq_name = "_QFarr_contig_ptr_target_writeEx"}
|
||||
! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
|
||||
! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_4]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
|
||||
! CHECK: %[[VAL_6:.*]] = fir.box_addr %[[VAL_3]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
|
||||
! CHECK: %[[VAL_7:.*]] = arith.constant 2 : i64
|
||||
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
|
||||
! CHECK: %[[VAL_9:.*]] = arith.constant 6 : i64
|
||||
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
|
||||
! CHECK: %[[VAL_11:.*]] = arith.constant 601 : i64
|
||||
! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_8]] : index
|
||||
! CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_14]], %[[VAL_10]] : index
|
||||
! CHECK: %[[VAL_16:.*]] = arith.divsi %[[VAL_15]], %[[VAL_10]] : index
|
||||
! CHECK: %[[VAL_17:.*]] = arith.cmpi sgt, %[[VAL_16]], %[[VAL_13]] : index
|
||||
! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_16]], %[[VAL_13]] : index
|
||||
! CHECK: %[[VAL_19:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1>
|
||||
! CHECK: %[[VAL_20:.*]] = fir.slice %[[VAL_8]], %[[VAL_12]], %[[VAL_10]] : (index, index, index) -> !fir.slice<1>
|
||||
! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_6]](%[[VAL_19]]) {{\[}}%[[VAL_20]]] : (!fir.ptr<!fir.array<?xf32>>, !fir.shapeshift<1>, !fir.slice<1>) -> !fir.array<?xf32>
|
||||
! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
|
||||
! CHECK: %[[VAL_23:.*]] = fir.array_load %[[VAL_2]](%[[VAL_22]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
|
||||
! CHECK: %[[VAL_24:.*]] = arith.constant 1 : index
|
||||
! CHECK: %[[VAL_25:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_18]], %[[VAL_24]] : index
|
||||
! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_26]] step %[[VAL_24]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_21]]) -> (!fir.array<?xf32>) {
|
||||
! CHECK: %[[VAL_30:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_28]] : (!fir.array<100xf32>, index) -> f32
|
||||
! CHECK: %[[VAL_31:.*]] = fir.array_update %[[VAL_29]], %[[VAL_30]], %[[VAL_28]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
|
||||
! CHECK: fir.result %[[VAL_31]] : !fir.array<?xf32>
|
||||
! CHECK: }
|
||||
! CHECK: fir.array_merge_store %[[VAL_21]], %[[VAL_32:.*]] to %[[VAL_6]]{{\[}}%[[VAL_20]]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ptr<!fir.array<?xf32>>, !fir.slice<1>
|
||||
! CHECK: return
|
||||
! CHECK: }
|
||||
|
||||
subroutine arr_contig_ptr_target_write(p)
|
||||
real, pointer, contiguous :: p(:)
|
||||
real :: x(100)
|
||||
p(2:601:6) = x
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: func @_QPpointer_result_as_value
|
||||
subroutine pointer_result_as_value()
|
||||
! Test that function pointer results used as values are correctly loaded.
|
||||
interface
|
||||
function returns_int_pointer()
|
||||
integer, pointer :: returns_int_pointer
|
||||
end function
|
||||
end interface
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<i32>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_6:.*]] = fir.call @_QPreturns_int_pointer() : () -> !fir.box<!fir.ptr<i32>>
|
||||
! CHECK: fir.save_result %[[VAL_6]] to %[[VAL_0]] : !fir.box<!fir.ptr<i32>>, !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
|
||||
! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
|
||||
! CHECK: fir.load %[[VAL_8]] : !fir.ptr<i32>
|
||||
print *, returns_int_pointer()
|
||||
end subroutine
|
||||
|
|
@ -18,68 +18,68 @@ module presults
|
|||
end interface
|
||||
real, pointer :: x
|
||||
real, pointer :: xa(:, :)
|
||||
contains
|
||||
contains
|
||||
|
||||
! CHECK-LABEL: test_scalar_null
|
||||
subroutine test_scalar_null()
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[VAL_1:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.embox %[[VAL_1]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.call @_QPbar_scalar(%[[VAL_0]]) : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> ()
|
||||
! CHECK-LABEL: test_scalar_null
|
||||
subroutine test_scalar_null()
|
||||
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[VAL_1:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[VAL_2:.*]] = fir.embox %[[VAL_1]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[VAL_2]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.call @_QPbar_scalar(%[[VAL_0]]) : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> ()
|
||||
call bar_scalar(null())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: test_scalar_null_mold
|
||||
subroutine test_scalar_null_mold()
|
||||
! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_4]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[VAL_5]] to %[[VAL_3]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.call @_QPbar_scalar(%[[VAL_3]]) : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> ()
|
||||
! CHECK-LABEL: test_scalar_null_mold
|
||||
subroutine test_scalar_null_mold()
|
||||
! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: %[[VAL_4:.*]] = fir.zero_bits !fir.ptr<f32>
|
||||
! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_4]] : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.store %[[VAL_5]] to %[[VAL_3]] : !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.call @_QPbar_scalar(%[[VAL_3]]) : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> ()
|
||||
call bar_scalar(null(x))
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: test_scalar_result
|
||||
subroutine test_scalar_result()
|
||||
! CHECK: %[[VAL_6:.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_7:.*]] = fir.call @_QPget_scalar_pointer() : () -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.save_result %[[VAL_7]] to %[[VAL_6]] : !fir.box<!fir.ptr<f32>>, !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.call @_QPbar_scalar(%[[VAL_6]]) : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> ()
|
||||
! CHECK-LABEL: test_scalar_result
|
||||
subroutine test_scalar_result()
|
||||
! CHECK: %[[VAL_6:.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_7:.*]] = fir.call @_QPget_scalar_pointer() : () -> !fir.box<!fir.ptr<f32>>
|
||||
! CHECK: fir.save_result %[[VAL_7]] to %[[VAL_6]] : !fir.box<!fir.ptr<f32>>, !fir.ref<!fir.box<!fir.ptr<f32>>>
|
||||
! CHECK: fir.call @_QPbar_scalar(%[[VAL_6]]) : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> ()
|
||||
call bar_scalar(get_scalar_pointer())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: test_null
|
||||
subroutine test_null()
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x?xf32>>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_8]], %[[VAL_8]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_10]](%[[VAL_11]]) : (!fir.ptr<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_12]] to %[[VAL_9]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: fir.call @_QPbar(%[[VAL_9]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>) -> ()
|
||||
! CHECK-LABEL: test_null
|
||||
subroutine test_null()
|
||||
! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_9:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: %[[VAL_10:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x?xf32>>
|
||||
! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_8]], %[[VAL_8]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_10]](%[[VAL_11]]) : (!fir.ptr<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_12]] to %[[VAL_9]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: fir.call @_QPbar(%[[VAL_9]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>) -> ()
|
||||
call bar(null())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: test_null_mold
|
||||
subroutine test_null_mold()
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x?xf32>>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_13]], %[[VAL_13]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_17:.*]] = fir.embox %[[VAL_15]](%[[VAL_16]]) : (!fir.ptr<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_17]] to %[[VAL_14]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: fir.call @_QPbar(%[[VAL_14]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>) -> ()
|
||||
! CHECK-LABEL: test_null_mold
|
||||
subroutine test_null_mold()
|
||||
! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
|
||||
! CHECK: %[[VAL_14:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: %[[VAL_15:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x?xf32>>
|
||||
! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_13]], %[[VAL_13]] : (index, index) -> !fir.shape<2>
|
||||
! CHECK: %[[VAL_17:.*]] = fir.embox %[[VAL_15]](%[[VAL_16]]) : (!fir.ptr<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.store %[[VAL_17]] to %[[VAL_14]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: fir.call @_QPbar(%[[VAL_14]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>) -> ()
|
||||
call bar(null(xa))
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
! CHECK-LABEL: test_result
|
||||
subroutine test_result()
|
||||
! CHECK: %[[VAL_18:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_19:.*]] = fir.call @_QPget_pointer() : () -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.save_result %[[VAL_19]] to %[[VAL_18]] : !fir.box<!fir.ptr<!fir.array<?x?xf32>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: fir.call @_QPbar(%[[VAL_18]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>) -> ()
|
||||
! CHECK-LABEL: test_result
|
||||
subroutine test_result()
|
||||
! CHECK: %[[VAL_18:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>> {bindc_name = ".result"}
|
||||
! CHECK: %[[VAL_19:.*]] = fir.call @_QPget_pointer() : () -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
|
||||
! CHECK: fir.save_result %[[VAL_19]] to %[[VAL_18]] : !fir.box<!fir.ptr<!fir.array<?x?xf32>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
|
||||
! CHECK: fir.call @_QPbar(%[[VAL_18]]) : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>) -> ()
|
||||
call bar(get_pointer())
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
||||
end module
|
||||
end module
|
||||
|
|
|
|||
|
|
@ -47,4 +47,4 @@ subroutine pointer_runtime(n)
|
|||
! CHECK-DAG: %[[ncast2:.*]] = fir.convert %[[n]] : (i32) -> i64
|
||||
! CHECK-DAG: %[[aBoxCast5:.*]] = fir.convert %[[aBoxAddr]] : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
|
||||
! CHECK: fir.call @{{.*}}PointerNullifyCharacter(%[[aBoxCast5]], %[[ncast2]], %c1{{.*}}, %c1{{.*}}, %c0{{.*}})
|
||||
end subroutine
|
||||
end subroutine
|
||||
|
|
|
|||
|
|
@ -42,4 +42,4 @@ subroutine pointerTests
|
|||
! CHECK: [[reg2:%[0-9]+]] = fir.convert [[reg1]] : (!fir.ref<none>) -> !fir.ptr<!fir.logical<4>>
|
||||
! CHECK: fir.has_value [[reg2]] : !fir.ptr<!fir.logical<4>>
|
||||
|
||||
end subroutine pointerTests
|
||||
end subroutine pointerTests
|
||||
|
|
|
|||
Loading…
Reference in New Issue