1! Test allocatable assignments 2! RUN: bbc -emit-fir %s -o - | FileCheck %s 3 4module alloc_assign 5 type t 6 integer :: i 7 end type 8contains 9 10! ----------------------------------------------------------------------------- 11! Test simple scalar RHS 12! ----------------------------------------------------------------------------- 13 14! CHECK-LABEL: func @_QMalloc_assignPtest_simple_scalar( 15! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<f32>>>{{.*}}) { 16subroutine test_simple_scalar(x) 17 real, allocatable :: x 18! CHECK: %[[VAL_1:.*]] = arith.constant 4.200000e+01 : f32 19! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<f32>>> 20! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32> 21! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<f32>) -> i64 22! CHECK: %[[VAL_5:.*]] = arith.constant 0 : i64 23! CHECK: %[[VAL_6:.*]] = arith.cmpi ne, %[[VAL_4]], %[[VAL_5]] : i64 24! CHECK: %[[VAL_7:.*]]:2 = fir.if %[[VAL_6]] -> (i1, !fir.heap<f32>) { 25! CHECK: %[[VAL_8:.*]] = arith.constant false 26! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_8]] -> (!fir.heap<f32>) { 27! CHECK: %[[VAL_10:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 28! CHECK: fir.result %[[VAL_10]] : !fir.heap<f32> 29! CHECK: } else { 30! CHECK: fir.result %[[VAL_3]] : !fir.heap<f32> 31! CHECK: } 32! CHECK: fir.result %[[VAL_8]], %[[VAL_11:.*]] : i1, !fir.heap<f32> 33! CHECK: } else { 34! CHECK: %[[VAL_12:.*]] = arith.constant true 35! CHECK: %[[VAL_13:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 36! CHECK: fir.result %[[VAL_12]], %[[VAL_13]] : i1, !fir.heap<f32> 37! CHECK: } 38! CHECK: fir.store %[[VAL_1]] to %[[VAL_14:.*]]#1 : !fir.heap<f32> 39! CHECK: fir.if %[[VAL_14]]#0 { 40! CHECK: fir.if %[[VAL_6]] { 41! CHECK: fir.freemem %[[VAL_3]] 42! CHECK: } 43! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_14]]#1 : (!fir.heap<f32>) -> !fir.box<!fir.heap<f32>> 44! CHECK: fir.store %[[VAL_15]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<f32>>> 45! CHECK: } 46 x = 42. 47end subroutine 48 49! CHECK-LABEL: func @_QMalloc_assignPtest_simple_local_scalar() { 50subroutine test_simple_local_scalar() 51 real, allocatable :: x 52! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.heap<f32> {uniq_name = "_QMalloc_assignFtest_simple_local_scalarEx.addr"} 53! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.heap<f32> 54! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<!fir.heap<f32>> 55! CHECK: %[[VAL_3:.*]] = arith.constant 4.200000e+01 : f32 56! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.heap<f32>> 57! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (!fir.heap<f32>) -> i64 58! CHECK: %[[VAL_6:.*]] = arith.constant 0 : i64 59! CHECK: %[[VAL_7:.*]] = arith.cmpi ne, %[[VAL_5]], %[[VAL_6]] : i64 60! CHECK: %[[VAL_8:.*]]:2 = fir.if %[[VAL_7]] -> (i1, !fir.heap<f32>) { 61! CHECK: %[[VAL_9:.*]] = arith.constant false 62! CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.heap<f32>) { 63! CHECK: %[[VAL_11:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 64! CHECK: fir.result %[[VAL_11]] : !fir.heap<f32> 65! CHECK: } else { 66! CHECK: fir.result %[[VAL_4]] : !fir.heap<f32> 67! CHECK: } 68! CHECK: fir.result %[[VAL_9]], %[[VAL_12:.*]] : i1, !fir.heap<f32> 69! CHECK: } else { 70! CHECK: %[[VAL_13:.*]] = arith.constant true 71! CHECK: %[[VAL_14:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 72! CHECK: fir.result %[[VAL_13]], %[[VAL_14]] : i1, !fir.heap<f32> 73! CHECK: } 74! CHECK: fir.store %[[VAL_3]] to %[[VAL_15:.*]]#1 : !fir.heap<f32> 75! CHECK: fir.if %[[VAL_15]]#0 { 76! CHECK: fir.if %[[VAL_7]] { 77! CHECK: fir.freemem %[[VAL_4]] 78! CHECK: } 79! CHECK: fir.store %[[VAL_15]]#1 to %[[VAL_1]] : !fir.ref<!fir.heap<f32>> 80! CHECK: } 81 x = 42. 82end subroutine 83 84! ----------------------------------------------------------------------------- 85! Test character scalar RHS 86! ----------------------------------------------------------------------------- 87 88! CHECK-LABEL: func @_QMalloc_assignPtest_deferred_char_scalar( 89! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>{{.*}}) { 90subroutine test_deferred_char_scalar(x) 91 character(:), allocatable :: x 92! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QQ{{.*}}) : !fir.ref<!fir.char<1,12>> 93! CHECK: %[[VAL_2:.*]] = arith.constant 12 : index 94! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 95! CHECK: %[[VAL_4:.*]] = fir.box_addr %[[VAL_3]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> !fir.heap<!fir.char<1,?>> 96! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (!fir.heap<!fir.char<1,?>>) -> i64 97! CHECK: %[[VAL_6:.*]] = arith.constant 0 : i64 98! CHECK: %[[VAL_7:.*]] = arith.cmpi ne, %[[VAL_5]], %[[VAL_6]] : i64 99! CHECK: %[[VAL_8:.*]]:2 = fir.if %[[VAL_7]] -> (i1, !fir.heap<!fir.char<1,?>>) { 100! CHECK: %[[VAL_9:.*]] = arith.constant false 101! CHECK: %[[VAL_10:.*]] = fir.box_elesize %[[VAL_3]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> index 102! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_10]], %[[VAL_2]] : index 103! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_11]], %[[VAL_11]], %[[VAL_9]] : i1 104! CHECK: %[[VAL_13:.*]] = fir.if %[[VAL_12]] -> (!fir.heap<!fir.char<1,?>>) { 105! CHECK: %[[VAL_14:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_2]] : index) {uniq_name = ".auto.alloc"} 106! CHECK: fir.result %[[VAL_14]] : !fir.heap<!fir.char<1,?>> 107! CHECK: } else { 108! CHECK: fir.result %[[VAL_4]] : !fir.heap<!fir.char<1,?>> 109! CHECK: } 110! CHECK: fir.result %[[VAL_12]], %[[VAL_15:.*]] : i1, !fir.heap<!fir.char<1,?>> 111! CHECK: } else { 112! CHECK: %[[VAL_16:.*]] = arith.constant true 113! CHECK: %[[VAL_17:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_2]] : index) {uniq_name = ".auto.alloc"} 114! CHECK: fir.result %[[VAL_16]], %[[VAL_17]] : i1, !fir.heap<!fir.char<1,?>> 115! CHECK: } 116 117! character assignment ... 118! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_8]]#1 : (!fir.heap<!fir.char<1,?>>) -> !fir.ref<i8> 119! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_24]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 120! character assignment ... 121 122! CHECK: fir.if %[[VAL_8]]#0 { 123! CHECK: fir.if %[[VAL_7]] { 124! CHECK: fir.freemem %[[VAL_4]] 125! CHECK: } 126! CHECK: %[[VAL_36:.*]] = fir.embox %[[VAL_8]]#1 typeparams %[[VAL_2]] : (!fir.heap<!fir.char<1,?>>, index) -> !fir.box<!fir.heap<!fir.char<1,?>>> 127! CHECK: fir.store %[[VAL_36]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 128! CHECK: } 129 x = "Hello world!" 130end subroutine 131 132! CHECK-LABEL: func @_QMalloc_assignPtest_cst_char_scalar( 133! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>>{{.*}}) { 134subroutine test_cst_char_scalar(x) 135 character(10), allocatable :: x 136! CHECK: %[[VAL_1:.*]] = arith.constant 10 : index 137! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QQ{{.*}}) : !fir.ref<!fir.char<1,12>> 138! CHECK: %[[VAL_3:.*]] = arith.constant 12 : index 139! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>> 140! CHECK: %[[VAL_5:.*]] = fir.box_addr %[[VAL_4]] : (!fir.box<!fir.heap<!fir.char<1,10>>>) -> !fir.heap<!fir.char<1,10>> 141! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (!fir.heap<!fir.char<1,10>>) -> i64 142! CHECK: %[[VAL_7:.*]] = arith.constant 0 : i64 143! CHECK: %[[VAL_8:.*]] = arith.cmpi ne, %[[VAL_6]], %[[VAL_7]] : i64 144! CHECK: %[[VAL_9:.*]]:2 = fir.if %[[VAL_8]] -> (i1, !fir.heap<!fir.char<1,10>>) { 145! CHECK: %[[VAL_10:.*]] = arith.constant false 146! CHECK: %[[VAL_11:.*]] = fir.if %[[VAL_10]] -> (!fir.heap<!fir.char<1,10>>) { 147! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.char<1,10> {uniq_name = ".auto.alloc"} 148! CHECK: fir.result %[[VAL_12]] : !fir.heap<!fir.char<1,10>> 149! CHECK: } else { 150! CHECK: fir.result %[[VAL_5]] : !fir.heap<!fir.char<1,10>> 151! CHECK: } 152! CHECK: fir.result %[[VAL_10]], %[[VAL_13:.*]] : i1, !fir.heap<!fir.char<1,10>> 153! CHECK: } else { 154! CHECK: %[[VAL_14:.*]] = arith.constant true 155! CHECK: %[[VAL_15:.*]] = fir.allocmem !fir.char<1,10> {uniq_name = ".auto.alloc"} 156! CHECK: fir.result %[[VAL_14]], %[[VAL_15]] : i1, !fir.heap<!fir.char<1,10>> 157! CHECK: } 158 159! character assignment ... 160! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_9]]#1 : (!fir.heap<!fir.char<1,10>>) -> !fir.ref<i8> 161! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_24]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 162! character assignment ... 163 164! CHECK: fir.if %[[VAL_9]]#0 { 165! CHECK: fir.if %[[VAL_8]] { 166! CHECK: fir.freemem %[[VAL_5]] 167! CHECK: } 168! CHECK: %[[VAL_34:.*]] = fir.embox %[[VAL_9]]#1 : (!fir.heap<!fir.char<1,10>>) -> !fir.box<!fir.heap<!fir.char<1,10>>> 169! CHECK: fir.store %[[VAL_34]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>> 170! CHECK: } 171 x = "Hello world!" 172end subroutine 173 174! CHECK-LABEL: func @_QMalloc_assignPtest_dyn_char_scalar( 175! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>{{.*}}, 176! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32>{{.*}}) { 177subroutine test_dyn_char_scalar(x, n) 178 integer :: n 179 character(n), allocatable :: x 180! CHECK: %[[VAL_2A:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32> 181! CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32 182! CHECK: %[[VAL_2B:.*]] = arith.cmpi sgt, %[[VAL_2A]], %[[c0_i32]] : i32 183! CHECK: %[[VAL_2:.*]] = arith.select %[[VAL_2B]], %[[VAL_2A]], %[[c0_i32]] : i32 184! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QQcl.48656C6C6F20776F726C6421) : !fir.ref<!fir.char<1,12>> 185! CHECK: %[[VAL_4:.*]] = arith.constant 12 : index 186! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 187! CHECK: %[[VAL_6:.*]] = fir.box_addr %[[VAL_5]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> !fir.heap<!fir.char<1,?>> 188! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (!fir.heap<!fir.char<1,?>>) -> i64 189! CHECK: %[[VAL_8:.*]] = arith.constant 0 : i64 190! CHECK: %[[VAL_9:.*]] = arith.cmpi ne, %[[VAL_7]], %[[VAL_8]] : i64 191! CHECK: %[[VAL_10:.*]]:2 = fir.if %[[VAL_9]] -> (i1, !fir.heap<!fir.char<1,?>>) { 192! CHECK: %[[VAL_11:.*]] = arith.constant false 193! CHECK: %[[VAL_12:.*]] = fir.if %[[VAL_11]] -> (!fir.heap<!fir.char<1,?>>) { 194! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_2]] : (i32) -> index 195! CHECK: %[[VAL_14:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_13]] : index) {uniq_name = ".auto.alloc"} 196! CHECK: fir.result %[[VAL_14]] : !fir.heap<!fir.char<1,?>> 197! CHECK: } else { 198! CHECK: fir.result %[[VAL_6]] : !fir.heap<!fir.char<1,?>> 199! CHECK: } 200! CHECK: fir.result %[[VAL_11]], %[[VAL_15:.*]] : i1, !fir.heap<!fir.char<1,?>> 201! CHECK: } else { 202! CHECK: %[[VAL_16:.*]] = arith.constant true 203! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_2]] : (i32) -> index 204! CHECK: %[[VAL_18:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_17]] : index) {uniq_name = ".auto.alloc"} 205! CHECK: fir.result %[[VAL_16]], %[[VAL_18]] : i1, !fir.heap<!fir.char<1,?>> 206! CHECK: } 207 208! character assignment ... 209! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_10]]#1 : (!fir.heap<!fir.char<1,?>>) -> !fir.ref<i8> 210! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_24]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 211! character assignment ... 212 213! CHECK: fir.if %[[VAL_10]]#0 { 214! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_2]] : (i32) -> index 215! CHECK: fir.if %[[VAL_9]] { 216! CHECK: fir.freemem %[[VAL_6]] 217! CHECK: } 218! CHECK: %[[VAL_40:.*]] = fir.embox %[[VAL_10]]#1 typeparams %[[VAL_39]] : (!fir.heap<!fir.char<1,?>>, index) -> !fir.box<!fir.heap<!fir.char<1,?>>> 219! CHECK: fir.store %[[VAL_40]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 220! CHECK: } 221 x = "Hello world!" 222end subroutine 223 224! CHECK-LABEL: func @_QMalloc_assignPtest_derived_scalar( 225! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>>>{{.*}}, 226! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.type<_QMalloc_assignTt{i:i32}>>{{.*}}) { 227subroutine test_derived_scalar(x, s) 228 type(t), allocatable :: x 229 type(t) :: s 230 x = s 231! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>>> 232! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>>) -> !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>> 233! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>) -> i64 234! CHECK: %[[VAL_5:.*]] = arith.constant 0 : i64 235! CHECK: %[[VAL_6:.*]] = arith.cmpi ne, %[[VAL_4]], %[[VAL_5]] : i64 236! CHECK: %[[VAL_7:.*]]:2 = fir.if %[[VAL_6]] -> (i1, !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>) { 237! CHECK: %[[VAL_8:.*]] = arith.constant false 238! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_8]] -> (!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>) { 239! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.type<_QMalloc_assignTt{i:i32}> {uniq_name = ".auto.alloc"} 240! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>> 241! CHECK: } else { 242! CHECK: fir.result %[[VAL_3]] : !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>> 243! CHECK: } 244! CHECK: fir.result %[[VAL_8]], %[[VAL_11:.*]] : i1, !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>> 245! CHECK: } else { 246! CHECK: %[[VAL_12:.*]] = arith.constant true 247! CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.type<_QMalloc_assignTt{i:i32}> {uniq_name = ".auto.alloc"} 248! CHECK: fir.result %[[VAL_12]], %[[VAL_13]] : i1, !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>> 249! CHECK: } 250! CHECK: %[[VAL_14:.*]] = fir.field_index i, !fir.type<_QMalloc_assignTt{i:i32}> 251! CHECK: %[[VAL_15:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_14]] : (!fir.ref<!fir.type<_QMalloc_assignTt{i:i32}>>, !fir.field) -> !fir.ref<i32> 252! CHECK: %[[VAL_14b:.*]] = fir.field_index i, !fir.type<_QMalloc_assignTt{i:i32}> 253! CHECK: %[[VAL_16:.*]] = fir.coordinate_of %[[VAL_7]]#1, %[[VAL_14b]] : (!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>, !fir.field) -> !fir.ref<i32> 254! CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32> 255! CHECK: fir.store %[[VAL_17]] to %[[VAL_16]] : !fir.ref<i32 256! CHECK: fir.if %[[VAL_7]]#0 { 257! CHECK: fir.if %[[VAL_6]] { 258! CHECK: fir.freemem %[[VAL_3]] 259! CHECK: } 260! CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_7]]#1 : (!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>) -> !fir.box<!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>> 261! CHECK: fir.store %[[VAL_19]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>>> 262! CHECK: } 263end subroutine 264 265! ----------------------------------------------------------------------------- 266! Test numeric/logical array RHS 267! ----------------------------------------------------------------------------- 268 269! CHECK-LABEL: func @_QMalloc_assignPtest_from_cst_shape_array( 270! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 271! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.array<2x3xf32>>{{.*}}) { 272subroutine test_from_cst_shape_array(x, y) 273 real, allocatable :: x(:, :) 274 real :: y(2, 3) 275! CHECK: %[[VAL_2_0:.*]] = arith.constant 2 : index 276! CHECK: %[[VAL_3_0:.*]] = arith.constant 3 : index 277! CHECK: %[[VAL_2:.*]] = arith.constant 2 : index 278! CHECK: %[[VAL_3:.*]] = arith.constant 3 : index 279! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 280! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_6]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 281! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 282! CHECK: %[[VAL_9:.*]] = arith.constant 0 : i64 283! CHECK: %[[VAL_10:.*]] = arith.cmpi ne, %[[VAL_8]], %[[VAL_9]] : i64 284! CHECK: %[[VAL_11:.*]]:2 = fir.if %[[VAL_10]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 285! CHECK: %[[VAL_12:.*]] = arith.constant false 286! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index 287! CHECK: %[[VAL_14:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_13]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 288! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index 289! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_15]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 290! CHECK: %[[VAL_17:.*]] = arith.cmpi ne, %[[VAL_14]]#1, %[[VAL_2]] : index 291! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_17]], %[[VAL_12]] : i1 292! CHECK: %[[VAL_19:.*]] = arith.cmpi ne, %[[VAL_16]]#1, %[[VAL_3]] : index 293! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_19]], %[[VAL_18]] : i1 294! CHECK: %[[VAL_21:.*]] = fir.if %[[VAL_20]] -> (!fir.heap<!fir.array<?x?xf32>>) { 295! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_2]], %[[VAL_3]] {uniq_name = ".auto.alloc"} 296! CHECK: fir.result %[[VAL_22]] : !fir.heap<!fir.array<?x?xf32>> 297! CHECK: } else { 298! CHECK: fir.result %[[VAL_7]] : !fir.heap<!fir.array<?x?xf32>> 299! CHECK: } 300! CHECK: fir.result %[[VAL_20]], %[[VAL_23:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 301! CHECK: } else { 302! CHECK: %[[VAL_24:.*]] = arith.constant true 303! CHECK: %[[VAL_25:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_2]], %[[VAL_3]] {uniq_name = ".auto.alloc"} 304! CHECK: fir.result %[[VAL_24]], %[[VAL_25]] : i1, !fir.heap<!fir.array<?x?xf32>> 305! CHECK: } 306 307! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 308! CHECK: %[[VAL_27:.*]] = fir.array_load %[[VAL_11]]#1(%[[VAL_26]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 309! normal array assignment .... 310! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_11]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 311 312! CHECK: fir.if %[[VAL_11]]#0 { 313! CHECK: fir.if %[[VAL_10]] { 314! CHECK: fir.freemem %[[VAL_7]] 315! CHECK: } 316! CHECK: %[[VAL_43:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 317! CHECK: %[[VAL_44:.*]] = fir.embox %[[VAL_11]]#1(%[[VAL_43]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xf32>>> 318! CHECK: fir.store %[[VAL_44]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 319! CHECK: } 320 x = y 321end subroutine 322 323! CHECK-LABEL: func @_QMalloc_assignPtest_from_dyn_shape_array( 324! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 325! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) { 326subroutine test_from_dyn_shape_array(x, y) 327 real, allocatable :: x(:, :) 328 real :: y(:, :) 329 x = y 330! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index 331! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_3]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 332! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index 333! CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_5]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 334! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 335! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 336! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 337! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64 338! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_10]] : i64 339! CHECK: %[[VAL_12:.*]]:2 = fir.if %[[VAL_11]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 340! CHECK: %[[VAL_13:.*]] = arith.constant false 341! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 342! CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_14]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 343! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index 344! CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_16]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 345! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_15]]#1, %[[VAL_4]]#1 : index 346! CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_18]], %[[VAL_13]] : i1 347! CHECK: %[[VAL_20:.*]] = arith.cmpi ne, %[[VAL_17]]#1, %[[VAL_6]]#1 : index 348! CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_20]], %[[VAL_19]] : i1 349! CHECK: %[[VAL_22:.*]] = fir.if %[[VAL_21]] -> (!fir.heap<!fir.array<?x?xf32>>) { 350! CHECK: %[[VAL_23:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_4]]#1, %[[VAL_6]]#1 {uniq_name = ".auto.alloc"} 351! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?x?xf32>> 352! CHECK: } else { 353! CHECK: fir.result %[[VAL_8]] : !fir.heap<!fir.array<?x?xf32>> 354! CHECK: } 355! CHECK: fir.result %[[VAL_21]], %[[VAL_24:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 356! CHECK: } else { 357! CHECK: %[[VAL_25:.*]] = arith.constant true 358! CHECK: %[[VAL_26:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_4]]#1, %[[VAL_6]]#1 {uniq_name = ".auto.alloc"} 359! CHECK: fir.result %[[VAL_25]], %[[VAL_26]] : i1, !fir.heap<!fir.array<?x?xf32>> 360! CHECK: } 361 362! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_4]]#1, %[[VAL_6]]#1 : (index, index) -> !fir.shape<2> 363! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_12]]#1(%[[VAL_27]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 364! normal array assignment .... 365! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_12]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 366 367! CHECK: fir.if %[[VAL_12]]#0 { 368! CHECK: fir.if %[[VAL_11]] { 369! CHECK: fir.freemem %[[VAL_8]] 370! CHECK: } 371! CHECK: %[[VAL_44:.*]] = fir.shape %[[VAL_4]]#1, %[[VAL_6]]#1 : (index, index) -> !fir.shape<2> 372! CHECK: %[[VAL_45:.*]] = fir.embox %[[VAL_12]]#1(%[[VAL_44]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xf32>>> 373! CHECK: fir.store %[[VAL_45]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 374! CHECK: } 375end subroutine 376 377! CHECK-LABEL: func @_QMalloc_assignPtest_with_lbounds( 378! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 379! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) { 380subroutine test_with_lbounds(x, y) 381 real, allocatable :: x(:, :) 382 real :: y(10:, 20:) 383! CHECK: %[[VAL_2:.*]] = arith.constant 10 : i64 384! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i64) -> index 385! CHECK: %[[VAL_4:.*]] = arith.constant 20 : i64 386! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i64) -> index 387! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index 388! CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_8]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 389! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index 390! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_10]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 391! CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 392! CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_12]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 393! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 394! CHECK: %[[VAL_15:.*]] = arith.constant 0 : i64 395! CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_14]], %[[VAL_15]] : i64 396! CHECK: %[[VAL_17:.*]]:2 = fir.if %[[VAL_16]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 397! CHECK: %[[VAL_18:.*]] = arith.constant false 398! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index 399! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_12]], %[[VAL_19]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 400! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index 401! CHECK: %[[VAL_22:.*]]:3 = fir.box_dims %[[VAL_12]], %[[VAL_21]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 402! CHECK: %[[VAL_23:.*]] = arith.cmpi ne, %[[VAL_20]]#1, %[[VAL_9]]#1 : index 403! CHECK: %[[VAL_24:.*]] = arith.select %[[VAL_23]], %[[VAL_23]], %[[VAL_18]] : i1 404! CHECK: %[[VAL_25:.*]] = arith.cmpi ne, %[[VAL_22]]#1, %[[VAL_11]]#1 : index 405! CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_25]], %[[VAL_24]] : i1 406! CHECK: %[[VAL_27:.*]] = fir.if %[[VAL_26]] -> (!fir.heap<!fir.array<?x?xf32>>) { 407! CHECK: %[[VAL_28:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_9]]#1, %[[VAL_11]]#1 {uniq_name = ".auto.alloc"} 408! CHECK: fir.result %[[VAL_28]] : !fir.heap<!fir.array<?x?xf32>> 409! CHECK: } else { 410! CHECK: fir.result %[[VAL_13]] : !fir.heap<!fir.array<?x?xf32>> 411! CHECK: } 412! CHECK: fir.result %[[VAL_26]], %[[VAL_29:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 413! CHECK: } else { 414! CHECK: %[[VAL_30:.*]] = arith.constant true 415! CHECK: %[[VAL_31:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_9]]#1, %[[VAL_11]]#1 {uniq_name = ".auto.alloc"} 416! CHECK: fir.result %[[VAL_30]], %[[VAL_31]] : i1, !fir.heap<!fir.array<?x?xf32>> 417! CHECK: } 418 419! CHECK: %[[VAL_32:.*]] = fir.shape %[[VAL_9]]#1, %[[VAL_11]]#1 : (index, index) -> !fir.shape<2> 420! CHECK: %[[VAL_33:.*]] = fir.array_load %[[VAL_17]]#1(%[[VAL_32]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 421! normal array assignment .... 422! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_17]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 423 424! CHECK: fir.if %[[VAL_17]]#0 { 425! CHECK: fir.if %[[VAL_16]] { 426! CHECK: fir.freemem %[[VAL_13]] 427! CHECK: } 428! CHECK: %[[VAL_49:.*]] = fir.shape_shift %[[VAL_3]], %[[VAL_9]]#1, %[[VAL_5]], %[[VAL_11]]#1 : (index, index, index, index) -> !fir.shapeshift<2> 429! CHECK: %[[VAL_50:.*]] = fir.embox %[[VAL_17]]#1(%[[VAL_49]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.box<!fir.heap<!fir.array<?x?xf32>>> 430! CHECK: fir.store %[[VAL_50]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 431! CHECK: } 432 x = y 433end subroutine 434 435! CHECK-LABEL: func @_QMalloc_assignPtest_runtime_shape( 436! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}) { 437subroutine test_runtime_shape(x) 438 real, allocatable :: x(:, :) 439 interface 440 function return_pointer() 441 real, pointer :: return_pointer(:, :) 442 end function 443 end interface 444! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>> {bindc_name = ".result"} 445! CHECK: %[[VAL_2:.*]] = fir.call @_QPreturn_pointer() : () -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>> 446! CHECK: fir.save_result %[[VAL_2]] to %[[VAL_1]] : !fir.box<!fir.ptr<!fir.array<?x?xf32>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>> 447! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>> 448! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index 449! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_4]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 450! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index 451! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_6]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 452! CHECK: %[[VAL_8:.*]] = fir.shift %[[VAL_5]]#0, %[[VAL_7]]#0 : (index, index) -> !fir.shift<2> 453! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index 454! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_10]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 455! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index 456! CHECK: %[[VAL_13:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_12]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 457! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_3]](%[[VAL_8]]) : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, !fir.shift<2>) -> !fir.array<?x?xf32> 458! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 459! CHECK: %[[VAL_15:.*]] = fir.box_addr %[[VAL_14]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 460! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 461! CHECK: %[[VAL_17:.*]] = arith.constant 0 : i64 462! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_16]], %[[VAL_17]] : i64 463! CHECK: %[[VAL_19:.*]]:2 = fir.if %[[VAL_18]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 464! CHECK: %[[VAL_20:.*]] = arith.constant false 465! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index 466! CHECK: %[[VAL_22:.*]]:3 = fir.box_dims %[[VAL_14]], %[[VAL_21]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 467! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index 468! CHECK: %[[VAL_24:.*]]:3 = fir.box_dims %[[VAL_14]], %[[VAL_23]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 469! CHECK: %[[VAL_25:.*]] = arith.cmpi ne, %[[VAL_22]]#1, %[[VAL_11]]#1 : index 470! CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_25]], %[[VAL_20]] : i1 471! CHECK: %[[VAL_27:.*]] = arith.cmpi ne, %[[VAL_24]]#1, %[[VAL_13]]#1 : index 472! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_27]], %[[VAL_26]] : i1 473! CHECK: %[[VAL_29:.*]] = fir.if %[[VAL_28]] -> (!fir.heap<!fir.array<?x?xf32>>) { 474! CHECK: %[[VAL_30:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_11]]#1, %[[VAL_13]]#1 {uniq_name = ".auto.alloc"} 475! CHECK: fir.result %[[VAL_30]] : !fir.heap<!fir.array<?x?xf32>> 476! CHECK: } else { 477! CHECK: fir.result %[[VAL_15]] : !fir.heap<!fir.array<?x?xf32>> 478! CHECK: } 479! CHECK: fir.result %[[VAL_28]], %[[VAL_31:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 480! CHECK: } else { 481! CHECK: %[[VAL_32:.*]] = arith.constant true 482! CHECK: %[[VAL_33:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_11]]#1, %[[VAL_13]]#1 {uniq_name = ".auto.alloc"} 483! CHECK: fir.result %[[VAL_32]], %[[VAL_33]] : i1, !fir.heap<!fir.array<?x?xf32>> 484! CHECK: } 485 486! CHECK-NOT: fir.call @_QPreturn_pointer() 487! CHECK: %[[VAL_34:.*]] = fir.shape %[[VAL_11]]#1, %[[VAL_13]]#1 : (index, index) -> !fir.shape<2> 488! CHECK: %[[VAL_35:.*]] = fir.array_load %[[VAL_19]]#1(%[[VAL_34]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 489! normal array assignment .... 490! CHECK-NOT: fir.call @_QPreturn_pointer() 491! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_19]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 492! CHECK-NOT: fir.call @_QPreturn_pointer() 493 494! CHECK: fir.if %[[VAL_19]]#0 { 495! CHECK: fir.if %[[VAL_18]] { 496! CHECK: fir.freemem %[[VAL_15]] 497! CHECK: } 498! CHECK: %[[VAL_56:.*]] = fir.shape %[[VAL_11]]#1, %[[VAL_13]]#1 : (index, index) -> !fir.shape<2> 499! CHECK: %[[VAL_57:.*]] = fir.embox %[[VAL_19]]#1(%[[VAL_56]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xf32>>> 500! CHECK: fir.store %[[VAL_57]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 501! CHECK: } 502 x = return_pointer() 503end subroutine 504 505! CHECK-LABEL: func @_QMalloc_assignPtest_scalar_rhs( 506subroutine test_scalar_rhs(x, y) 507 real, allocatable :: x(:) 508 real :: y 509 ! CHECK: fir.if %{{.*}} -> {{.*}} { 510 ! CHECK: fir.if %false -> {{.*}} { 511 ! CHECK: } 512 ! CHECK: } else { 513 ! CHECK: %[[error_msg_addr:.*]] = fir.address_of(@[[error_message:.*]]) : !fir.ref<!fir.char<1,76>> 514 ! CHECK: %[[msg_addr_cast:.*]] = fir.convert %[[error_msg_addr]] : (!fir.ref<!fir.char<1,76>>) -> !fir.ref<i8> 515 ! CHECK: %15 = fir.call @_FortranAReportFatalUserError(%[[msg_addr_cast]], %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i32) -> none 516 ! CHECK-NOT: allocmem 517 ! CHECK: } 518 x = y 519end subroutine 520 521! ----------------------------------------------------------------------------- 522! Test character array RHS 523! ----------------------------------------------------------------------------- 524 525 526! Hit TODO: gathering lhs length in array expression 527!subroutine test_deferred_char_rhs_scalar(x) 528! character(:), allocatable :: x(:) 529! x = "Hello world!" 530!end subroutine 531 532! CHECK: func @_QMalloc_assignPtest_cst_char_rhs_scalar( 533subroutine test_cst_char_rhs_scalar(x) 534 character(10), allocatable :: x(:) 535 x = "Hello world!" 536 ! CHECK: fir.if %{{.*}} -> {{.*}} { 537 ! CHECK: fir.if %false -> {{.*}} { 538 ! CHECK: } 539 ! CHECK: } else { 540 ! TODO: runtime error if unallocated 541 ! CHECK-NOT: allocmem 542 ! CHECK: } 543end subroutine 544 545! CHECK: func @_QMalloc_assignPtest_dyn_char_rhs_scalar( 546subroutine test_dyn_char_rhs_scalar(x, n) 547 integer :: n 548 character(n), allocatable :: x(:) 549 x = "Hello world!" 550 ! CHECK: fir.if %{{.*}} -> {{.*}} { 551 ! CHECK: fir.if %false -> {{.*}} { 552 ! CHECK: } 553 ! CHECK: } else { 554 ! TODO: runtime error if unallocated 555 ! CHECK-NOT: allocmem 556 ! CHECK: } 557end subroutine 558 559! Hit TODO: gathering lhs length in array expression 560!subroutine test_deferred_char(x, c) 561! character(:), allocatable :: x(:) 562! character(12) :: c(20) 563! x = "Hello world!" 564!end subroutine 565 566! CHECK-LABEL: func @_QMalloc_assignPtest_cst_char( 567! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>>{{.*}}, 568! CHECK-SAME: %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 569subroutine test_cst_char(x, c) 570 character(10), allocatable :: x(:) 571 character(12) :: c(20) 572! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 573! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<20x!fir.char<1,12>>> 574! CHECK: %[[VAL_4_0:.*]] = arith.constant 20 : index 575! CHECK: %[[VAL_4:.*]] = arith.constant 20 : index 576! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4_0]] : (index) -> !fir.shape<1> 577! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>> 578! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>) -> !fir.heap<!fir.array<?x!fir.char<1,10>>> 579! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> i64 580! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64 581! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_10]] : i64 582! CHECK: %[[VAL_12:.*]]:2 = fir.if %[[VAL_11]] -> (i1, !fir.heap<!fir.array<?x!fir.char<1,10>>>) { 583! CHECK: %[[VAL_13:.*]] = arith.constant false 584! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 585! CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_14]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>, index) -> (index, index, index) 586! CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_15]]#1, %[[VAL_4]] : index 587! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_16]], %[[VAL_16]], %[[VAL_13]] : i1 588! CHECK: %[[VAL_18:.*]] = fir.if %[[VAL_17]] -> (!fir.heap<!fir.array<?x!fir.char<1,10>>>) { 589! CHECK: %[[VAL_19:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_4]] {uniq_name = ".auto.alloc"} 590! CHECK: fir.result %[[VAL_19]] : !fir.heap<!fir.array<?x!fir.char<1,10>>> 591! CHECK: } else { 592! CHECK: fir.result %[[VAL_8]] : !fir.heap<!fir.array<?x!fir.char<1,10>>> 593! CHECK: } 594! CHECK: fir.result %[[VAL_17]], %[[VAL_20:.*]] : i1, !fir.heap<!fir.array<?x!fir.char<1,10>>> 595! CHECK: } else { 596! CHECK: %[[VAL_21:.*]] = arith.constant true 597! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_4]] {uniq_name = ".auto.alloc"} 598! CHECK: fir.result %[[VAL_21]], %[[VAL_22]] : i1, !fir.heap<!fir.array<?x!fir.char<1,10>>> 599! CHECK: } 600 601! CHECK: %[[VAL_23:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 602! CHECK: %[[VAL_24:.*]] = fir.array_load %[[VAL_12]]#1(%[[VAL_23]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<?x!fir.char<1,10>> 603! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_12]]#1 : !fir.array<?x!fir.char<1,10>>, !fir.array<?x!fir.char<1,10>>, !fir.heap<!fir.array<?x!fir.char<1,10>>> 604! CHECK: fir.if %[[VAL_12]]#0 { 605! CHECK: fir.if %[[VAL_11]] { 606! CHECK: fir.freemem %[[VAL_8]] 607! CHECK: } 608! CHECK: %[[VAL_36:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 609! CHECK: %[[VAL_37:.*]] = fir.embox %[[VAL_12]]#1(%[[VAL_36]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>> 610! CHECK: fir.store %[[VAL_37]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>> 611! CHECK: } 612 x = c 613end subroutine 614 615! CHECK-LABEL: func @_QMalloc_assignPtest_dyn_char( 616! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<i32>{{.*}}, %[[VAL_2:.*]]: !fir.boxchar<1>{{.*}}) { 617subroutine test_dyn_char(x, n, c) 618 integer :: n 619 character(n), allocatable :: x(:) 620 character(*) :: c(20) 621! CHECK: %[[VAL_3:.*]]:2 = fir.unboxchar %[[VAL_2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 622! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<20x!fir.char<1,?>>> 623! CHECK: %[[VAL_5_0:.*]] = arith.constant 20 : index 624! CHECK: %[[VAL_6A:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32> 625! CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32 626! CHECK: %[[VAL_6B:.*]] = arith.cmpi sgt, %[[VAL_6A]], %[[c0_i32]] : i32 627! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_6B]], %[[VAL_6A]], %[[c0_i32]] : i32 628! CHECK: %[[VAL_5:.*]] = arith.constant 20 : index 629! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_5_0]] : (index) -> !fir.shape<1> 630! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>> 631! CHECK: %[[VAL_10:.*]] = fir.box_addr %[[VAL_9]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> !fir.heap<!fir.array<?x!fir.char<1,?>>> 632! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> i64 633! CHECK: %[[VAL_12:.*]] = arith.constant 0 : i64 634! CHECK: %[[VAL_13:.*]] = arith.cmpi ne, %[[VAL_11]], %[[VAL_12]] : i64 635! CHECK: %[[VAL_14:.*]]:2 = fir.if %[[VAL_13]] -> (i1, !fir.heap<!fir.array<?x!fir.char<1,?>>>) { 636! CHECK: %[[VAL_15:.*]] = arith.constant false 637! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index 638! CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_9]], %[[VAL_16]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>, index) -> (index, index, index) 639! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_17]]#1, %[[VAL_5]] : index 640! CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_18]], %[[VAL_15]] : i1 641! CHECK: %[[VAL_20:.*]] = fir.if %[[VAL_19]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) { 642! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 643! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_21]] : index), %[[VAL_5]] {uniq_name = ".auto.alloc"} 644! CHECK: fir.result %[[VAL_22]] : !fir.heap<!fir.array<?x!fir.char<1,?>>> 645! CHECK: } else { 646! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?x!fir.char<1,?>>> 647! CHECK: } 648! CHECK: fir.result %[[VAL_19]], %[[VAL_23:.*]] : i1, !fir.heap<!fir.array<?x!fir.char<1,?>>> 649! CHECK: } else { 650! CHECK: %[[VAL_24:.*]] = arith.constant true 651! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 652! CHECK: %[[VAL_26:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_25]] : index), %[[VAL_5]] {uniq_name = ".auto.alloc"} 653! CHECK: fir.result %[[VAL_24]], %[[VAL_26]] : i1, !fir.heap<!fir.array<?x!fir.char<1,?>>> 654! CHECK: } 655 656! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 657! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_14]]#1(%[[VAL_27]]) typeparams %[[VAL_6]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, i32) -> !fir.array<?x!fir.char<1,?>> 658! normal array assignment .... 659! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_14]]#1 typeparams %[[VAL_6]] : !fir.array<?x!fir.char<1,?>>, !fir.array<?x!fir.char<1,?>>, !fir.heap<!fir.array<?x!fir.char<1,?>>>, i32 660 661! CHECK: fir.if %[[VAL_14]]#0 { 662! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 663! CHECK: fir.if %[[VAL_13]] { 664! CHECK: fir.freemem %[[VAL_10]] 665! CHECK: } 666! CHECK: %[[VAL_40:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 667! CHECK: %[[VAL_41:.*]] = fir.embox %[[VAL_14]]#1(%[[VAL_40]]) typeparams %[[VAL_39]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>> 668! CHECK: fir.store %[[VAL_41]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>> 669! CHECK: } 670 x = c 671end subroutine 672 673! CHECK-LABEL: func @_QMalloc_assignPtest_derived_with_init 674subroutine test_derived_with_init(x, y) 675 type t 676 integer, allocatable :: a(:) 677 end type 678 type(t), allocatable :: x 679 type(t) :: y 680 ! The allocatable component of `x` need to be initialized 681 ! during the automatic allocation (setting its rank and allocation 682 ! status) before it is assigned with the component of `y` 683 x = y 684! CHECK: fir.if %{{.*}} { 685! CHECK: %[[VAL_11:.*]] = fir.allocmem !fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}> {uniq_name = ".auto.alloc"} 686! CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_11]] : (!fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> !fir.box<!fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>> 687! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_12]] : (!fir.box<!fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>>) -> !fir.box<none> 688! CHECK: fir.call @_FortranAInitialize(%[[VAL_15]], %{{.*}}, %{{.*}}) : (!fir.box<none>, !fir.ref<i8>, i32) -> none 689! CHECK: fir.result %[[VAL_11]] : !fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>> 690! CHECK: } else { 691! CHECK: fir.result %{{.*}} : !fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>> 692! CHECK: } 693end subroutine 694 695! CHECK-LABEL: func @_QMalloc_assignPtest_vector_subscript( 696! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {fir.bindc_name = "x"}, 697! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "y"}, 698! CHECK-SAME: %[[VAL_2:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "v"}) { 699subroutine test_vector_subscript(x, y, v) 700 ! Test that the new shape is computed correctly in presence of 701 ! vector subscripts on the RHS and that it is used to allocate 702 ! the new storage and to drive the implicit loop. 703 integer, allocatable :: x(:) 704 integer :: y(:), v(:) 705 x = y(v) 706! CHECK: %[[VAL_3:.*]] = arith.constant 1 : index 707! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index 708! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_4]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 709! CHECK: %[[VAL_6:.*]] = arith.constant 0 : index 710! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_6]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 711! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_2]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32> 712! CHECK: %[[VAL_9:.*]] = arith.cmpi sgt, %[[VAL_7]]#1, %[[VAL_5]]#1 : index 713! CHECK: %[[VAL_10:.*]] = arith.select %[[VAL_9]], %[[VAL_5]]#1, %[[VAL_7]]#1 : index 714! CHECK: fir.if {{.*}} { 715! CHECK: %[[VAL_18:.*]] = arith.constant false 716! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 717! CHECK: %[[VAL_21:.*]] = arith.cmpi ne, %[[VAL_20]]#1, %[[VAL_10]] : index 718! CHECK: %[[VAL_22:.*]] = arith.select %[[VAL_21]], %[[VAL_21]], %[[VAL_18]] : i1 719! CHECK: fir.if %[[VAL_22]] {{.*}} { 720! CHECK: %[[VAL_24:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]] {uniq_name = ".auto.alloc"} 721! CHECK: fir.result %[[VAL_24]] : !fir.heap<!fir.array<?xi32>> 722! CHECK: } else { 723! CHECK: fir.result %{{.*}} : !fir.heap<!fir.array<?xi32>> 724! CHECK: } 725! CHECK: fir.result %{{.*}}, %{{.*}} 726! CHECK: } else { 727! CHECK: %[[VAL_27:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]] {uniq_name = ".auto.alloc"} 728! CHECK: fir.result %{{.*}}, %[[VAL_27]] : i1, !fir.heap<!fir.array<?xi32>> 729! CHECK: } 730! CHECK: %[[VAL_28:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1> 731! CHECK: %[[VAL_29:.*]] = fir.array_load %[[VAL_30:.*]]#1(%[[VAL_28]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.array<?xi32> 732! CHECK: %[[VAL_31:.*]] = arith.constant 1 : index 733! CHECK: %[[VAL_32:.*]] = arith.constant 0 : index 734! CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_10]], %[[VAL_31]] : index 735! CHECK: %[[VAL_34:.*]] = fir.do_loop %[[VAL_35:.*]] = %[[VAL_32]] to %[[VAL_33]] step %[[VAL_31]] {{.*}} { 736! CHECK: } 737end subroutine 738 739! CHECK: fir.global linkonce @[[error_message]] constant : !fir.char<1,76> { 740! CHECK: %[[msg:.*]] = fir.string_lit "array left hand side must be allocated when the right hand side is a scalar\00"(76) : !fir.char<1,76> 741! CHECK: fir.has_value %[[msg:.*]] : !fir.char<1,76> 742! CHECK: } 743 744end module 745 746! use alloc_assign 747! real :: y(2, 3) = reshape([1,2,3,4,5,6], [2,3]) 748! real, allocatable :: x (:, :) 749! allocate(x(2,2)) 750! call test_with_lbounds(x, y) 751! print *, x(10, 20) 752! print *, x 753!end 754