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.p0i8.p0i8.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.p0i8.p0i8.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.p0i8.p0i8.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_16:.*]] = fir.coordinate_of %[[VAL_7]]#1, %[[VAL_14]] : (!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>, !fir.field) -> !fir.ref<i32> 253! CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32> 254! CHECK: fir.store %[[VAL_17]] to %[[VAL_16]] : !fir.ref<i32 255! CHECK: fir.if %[[VAL_7]]#0 { 256! CHECK: fir.if %[[VAL_6]] { 257! CHECK: fir.freemem %[[VAL_3]] 258! CHECK: } 259! 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}>>> 260! CHECK: fir.store %[[VAL_19]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>>> 261! CHECK: } 262end subroutine 263 264! ----------------------------------------------------------------------------- 265! Test numeric/logical array RHS 266! ----------------------------------------------------------------------------- 267 268! CHECK-LABEL: func @_QMalloc_assignPtest_from_cst_shape_array( 269! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 270! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.array<2x3xf32>>{{.*}}) { 271subroutine test_from_cst_shape_array(x, y) 272 real, allocatable :: x(:, :) 273 real :: y(2, 3) 274! CHECK: %[[VAL_2_0:.*]] = arith.constant 2 : index 275! CHECK: %[[VAL_3_0:.*]] = arith.constant 3 : index 276! CHECK: %[[VAL_2:.*]] = arith.constant 2 : index 277! CHECK: %[[VAL_3:.*]] = arith.constant 3 : index 278! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 279! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_6]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 280! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 281! CHECK: %[[VAL_9:.*]] = arith.constant 0 : i64 282! CHECK: %[[VAL_10:.*]] = arith.cmpi ne, %[[VAL_8]], %[[VAL_9]] : i64 283! CHECK: %[[VAL_11:.*]]:2 = fir.if %[[VAL_10]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 284! CHECK: %[[VAL_12:.*]] = arith.constant false 285! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index 286! CHECK: %[[VAL_14:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_13]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 287! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index 288! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_15]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 289! CHECK: %[[VAL_17:.*]] = arith.cmpi ne, %[[VAL_14]]#1, %[[VAL_2]] : index 290! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_17]], %[[VAL_12]] : i1 291! CHECK: %[[VAL_19:.*]] = arith.cmpi ne, %[[VAL_16]]#1, %[[VAL_3]] : index 292! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_19]], %[[VAL_18]] : i1 293! CHECK: %[[VAL_21:.*]] = fir.if %[[VAL_20]] -> (!fir.heap<!fir.array<?x?xf32>>) { 294! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_2]], %[[VAL_3]] {uniq_name = ".auto.alloc"} 295! CHECK: fir.result %[[VAL_22]] : !fir.heap<!fir.array<?x?xf32>> 296! CHECK: } else { 297! CHECK: fir.result %[[VAL_7]] : !fir.heap<!fir.array<?x?xf32>> 298! CHECK: } 299! CHECK: fir.result %[[VAL_20]], %[[VAL_23:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 300! CHECK: } else { 301! CHECK: %[[VAL_24:.*]] = arith.constant true 302! CHECK: %[[VAL_25:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_2]], %[[VAL_3]] {uniq_name = ".auto.alloc"} 303! CHECK: fir.result %[[VAL_24]], %[[VAL_25]] : i1, !fir.heap<!fir.array<?x?xf32>> 304! CHECK: } 305 306! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 307! CHECK: %[[VAL_27:.*]] = fir.array_load %[[VAL_11]]#1(%[[VAL_26]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 308! normal array assignment .... 309! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_11]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 310 311! CHECK: fir.if %[[VAL_11]]#0 { 312! CHECK: fir.if %[[VAL_10]] { 313! CHECK: fir.freemem %[[VAL_7]] 314! CHECK: } 315! CHECK: %[[VAL_43:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 316! 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>>> 317! CHECK: fir.store %[[VAL_44]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 318! CHECK: } 319 x = y 320end subroutine 321 322! CHECK-LABEL: func @_QMalloc_assignPtest_from_dyn_shape_array( 323! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 324! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) { 325subroutine test_from_dyn_shape_array(x, y) 326 real, allocatable :: x(:, :) 327 real :: y(:, :) 328 x = y 329! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index 330! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_3]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 331! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index 332! CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_5]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 333! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 334! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 335! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 336! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64 337! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_10]] : i64 338! CHECK: %[[VAL_12:.*]]:2 = fir.if %[[VAL_11]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 339! CHECK: %[[VAL_13:.*]] = arith.constant false 340! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 341! CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_14]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 342! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index 343! CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_16]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 344! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_15]]#1, %[[VAL_4]]#1 : index 345! CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_18]], %[[VAL_13]] : i1 346! CHECK: %[[VAL_20:.*]] = arith.cmpi ne, %[[VAL_17]]#1, %[[VAL_6]]#1 : index 347! CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_20]], %[[VAL_19]] : i1 348! CHECK: %[[VAL_22:.*]] = fir.if %[[VAL_21]] -> (!fir.heap<!fir.array<?x?xf32>>) { 349! CHECK: %[[VAL_23:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_4]]#1, %[[VAL_6]]#1 {uniq_name = ".auto.alloc"} 350! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?x?xf32>> 351! CHECK: } else { 352! CHECK: fir.result %[[VAL_8]] : !fir.heap<!fir.array<?x?xf32>> 353! CHECK: } 354! CHECK: fir.result %[[VAL_21]], %[[VAL_24:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 355! CHECK: } else { 356! CHECK: %[[VAL_25:.*]] = arith.constant true 357! CHECK: %[[VAL_26:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_4]]#1, %[[VAL_6]]#1 {uniq_name = ".auto.alloc"} 358! CHECK: fir.result %[[VAL_25]], %[[VAL_26]] : i1, !fir.heap<!fir.array<?x?xf32>> 359! CHECK: } 360 361! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_4]]#1, %[[VAL_6]]#1 : (index, index) -> !fir.shape<2> 362! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_12]]#1(%[[VAL_27]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 363! normal array assignment .... 364! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_12]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 365 366! CHECK: fir.if %[[VAL_12]]#0 { 367! CHECK: fir.if %[[VAL_11]] { 368! CHECK: fir.freemem %[[VAL_8]] 369! CHECK: } 370! CHECK: %[[VAL_44:.*]] = fir.shape %[[VAL_4]]#1, %[[VAL_6]]#1 : (index, index) -> !fir.shape<2> 371! 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>>> 372! CHECK: fir.store %[[VAL_45]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 373! CHECK: } 374end subroutine 375 376! CHECK-LABEL: func @_QMalloc_assignPtest_with_lbounds( 377! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 378! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) { 379subroutine test_with_lbounds(x, y) 380 real, allocatable :: x(:, :) 381 real :: y(10:, 20:) 382! CHECK: %[[VAL_2:.*]] = arith.constant 10 : i64 383! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i64) -> index 384! CHECK: %[[VAL_4:.*]] = arith.constant 20 : i64 385! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i64) -> index 386! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index 387! CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_8]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 388! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index 389! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_10]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 390! CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 391! CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_12]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 392! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 393! CHECK: %[[VAL_15:.*]] = arith.constant 0 : i64 394! CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_14]], %[[VAL_15]] : i64 395! CHECK: %[[VAL_17:.*]]:2 = fir.if %[[VAL_16]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 396! CHECK: %[[VAL_18:.*]] = arith.constant false 397! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index 398! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_12]], %[[VAL_19]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 399! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index 400! CHECK: %[[VAL_22:.*]]:3 = fir.box_dims %[[VAL_12]], %[[VAL_21]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 401! CHECK: %[[VAL_23:.*]] = arith.cmpi ne, %[[VAL_20]]#1, %[[VAL_9]]#1 : index 402! CHECK: %[[VAL_24:.*]] = arith.select %[[VAL_23]], %[[VAL_23]], %[[VAL_18]] : i1 403! CHECK: %[[VAL_25:.*]] = arith.cmpi ne, %[[VAL_22]]#1, %[[VAL_11]]#1 : index 404! CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_25]], %[[VAL_24]] : i1 405! CHECK: %[[VAL_27:.*]] = fir.if %[[VAL_26]] -> (!fir.heap<!fir.array<?x?xf32>>) { 406! CHECK: %[[VAL_28:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_9]]#1, %[[VAL_11]]#1 {uniq_name = ".auto.alloc"} 407! CHECK: fir.result %[[VAL_28]] : !fir.heap<!fir.array<?x?xf32>> 408! CHECK: } else { 409! CHECK: fir.result %[[VAL_13]] : !fir.heap<!fir.array<?x?xf32>> 410! CHECK: } 411! CHECK: fir.result %[[VAL_26]], %[[VAL_29:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 412! CHECK: } else { 413! CHECK: %[[VAL_30:.*]] = arith.constant true 414! CHECK: %[[VAL_31:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_9]]#1, %[[VAL_11]]#1 {uniq_name = ".auto.alloc"} 415! CHECK: fir.result %[[VAL_30]], %[[VAL_31]] : i1, !fir.heap<!fir.array<?x?xf32>> 416! CHECK: } 417 418! CHECK: %[[VAL_32:.*]] = fir.shape %[[VAL_9]]#1, %[[VAL_11]]#1 : (index, index) -> !fir.shape<2> 419! CHECK: %[[VAL_33:.*]] = fir.array_load %[[VAL_17]]#1(%[[VAL_32]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 420! normal array assignment .... 421! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_17]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 422 423! CHECK: fir.if %[[VAL_17]]#0 { 424! CHECK: fir.if %[[VAL_16]] { 425! CHECK: fir.freemem %[[VAL_13]] 426! CHECK: } 427! CHECK: %[[VAL_49:.*]] = fir.shape_shift %[[VAL_3]], %[[VAL_9]]#1, %[[VAL_5]], %[[VAL_11]]#1 : (index, index, index, index) -> !fir.shapeshift<2> 428! 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>>> 429! CHECK: fir.store %[[VAL_50]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 430! CHECK: } 431 x = y 432end subroutine 433 434! CHECK-LABEL: func @_QMalloc_assignPtest_runtime_shape( 435! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}) { 436subroutine test_runtime_shape(x) 437 real, allocatable :: x(:, :) 438 interface 439 function return_pointer() 440 real, pointer :: return_pointer(:, :) 441 end function 442 end interface 443! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>> {bindc_name = ".result"} 444! CHECK: %[[VAL_2:.*]] = fir.call @_QPreturn_pointer() : () -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>> 445! 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>>>> 446! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>> 447! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index 448! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_4]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 449! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index 450! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_6]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 451! CHECK: %[[VAL_8:.*]] = fir.shift %[[VAL_5]]#0, %[[VAL_7]]#0 : (index, index) -> !fir.shift<2> 452! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index 453! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_10]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 454! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index 455! CHECK: %[[VAL_13:.*]]:3 = fir.box_dims %[[VAL_3]], %[[VAL_12]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index) 456! 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> 457! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 458! CHECK: %[[VAL_15:.*]] = fir.box_addr %[[VAL_14]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 459! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 460! CHECK: %[[VAL_17:.*]] = arith.constant 0 : i64 461! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_16]], %[[VAL_17]] : i64 462! CHECK: %[[VAL_19:.*]]:2 = fir.if %[[VAL_18]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 463! CHECK: %[[VAL_20:.*]] = arith.constant false 464! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index 465! CHECK: %[[VAL_22:.*]]:3 = fir.box_dims %[[VAL_14]], %[[VAL_21]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 466! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index 467! CHECK: %[[VAL_24:.*]]:3 = fir.box_dims %[[VAL_14]], %[[VAL_23]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 468! CHECK: %[[VAL_25:.*]] = arith.cmpi ne, %[[VAL_22]]#1, %[[VAL_11]]#1 : index 469! CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_25]], %[[VAL_20]] : i1 470! CHECK: %[[VAL_27:.*]] = arith.cmpi ne, %[[VAL_24]]#1, %[[VAL_13]]#1 : index 471! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_27]], %[[VAL_26]] : i1 472! CHECK: %[[VAL_29:.*]] = fir.if %[[VAL_28]] -> (!fir.heap<!fir.array<?x?xf32>>) { 473! CHECK: %[[VAL_30:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_11]]#1, %[[VAL_13]]#1 {uniq_name = ".auto.alloc"} 474! CHECK: fir.result %[[VAL_30]] : !fir.heap<!fir.array<?x?xf32>> 475! CHECK: } else { 476! CHECK: fir.result %[[VAL_15]] : !fir.heap<!fir.array<?x?xf32>> 477! CHECK: } 478! CHECK: fir.result %[[VAL_28]], %[[VAL_31:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 479! CHECK: } else { 480! CHECK: %[[VAL_32:.*]] = arith.constant true 481! CHECK: %[[VAL_33:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_11]]#1, %[[VAL_13]]#1 {uniq_name = ".auto.alloc"} 482! CHECK: fir.result %[[VAL_32]], %[[VAL_33]] : i1, !fir.heap<!fir.array<?x?xf32>> 483! CHECK: } 484 485! CHECK-NOT: fir.call @_QPreturn_pointer() 486! CHECK: %[[VAL_34:.*]] = fir.shape %[[VAL_11]]#1, %[[VAL_13]]#1 : (index, index) -> !fir.shape<2> 487! CHECK: %[[VAL_35:.*]] = fir.array_load %[[VAL_19]]#1(%[[VAL_34]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 488! normal array assignment .... 489! CHECK-NOT: fir.call @_QPreturn_pointer() 490! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_19]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 491! CHECK-NOT: fir.call @_QPreturn_pointer() 492 493! CHECK: fir.if %[[VAL_19]]#0 { 494! CHECK: fir.if %[[VAL_18]] { 495! CHECK: fir.freemem %[[VAL_15]] 496! CHECK: } 497! CHECK: %[[VAL_56:.*]] = fir.shape %[[VAL_11]]#1, %[[VAL_13]]#1 : (index, index) -> !fir.shape<2> 498! 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>>> 499! CHECK: fir.store %[[VAL_57]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 500! CHECK: } 501 x = return_pointer() 502end subroutine 503 504! CHECK-LABEL: func @_QMalloc_assignPtest_scalar_rhs( 505subroutine test_scalar_rhs(x, y) 506 real, allocatable :: x(:) 507 real :: y 508 ! CHECK: fir.if %{{.*}} -> {{.*}} { 509 ! CHECK: fir.if %false -> {{.*}} { 510 ! CHECK: } 511 ! CHECK: } else { 512 ! CHECK: %[[error_msg_addr:.*]] = fir.address_of(@[[error_message:.*]]) : !fir.ref<!fir.char<1,76>> 513 ! CHECK: %[[msg_addr_cast:.*]] = fir.convert %[[error_msg_addr]] : (!fir.ref<!fir.char<1,76>>) -> !fir.ref<i8> 514 ! CHECK: %15 = fir.call @_FortranAReportFatalUserError(%[[msg_addr_cast]], %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i32) -> none 515 ! CHECK-NOT: allocmem 516 ! CHECK: } 517 x = y 518end subroutine 519 520! ----------------------------------------------------------------------------- 521! Test character array RHS 522! ----------------------------------------------------------------------------- 523 524 525! Hit TODO: gathering lhs length in array expression 526!subroutine test_deferred_char_rhs_scalar(x) 527! character(:), allocatable :: x(:) 528! x = "Hello world!" 529!end subroutine 530 531! CHECK: func @_QMalloc_assignPtest_cst_char_rhs_scalar( 532subroutine test_cst_char_rhs_scalar(x) 533 character(10), allocatable :: x(:) 534 x = "Hello world!" 535 ! CHECK: fir.if %{{.*}} -> {{.*}} { 536 ! CHECK: fir.if %false -> {{.*}} { 537 ! CHECK: } 538 ! CHECK: } else { 539 ! TODO: runtime error if unallocated 540 ! CHECK-NOT: allocmem 541 ! CHECK: } 542end subroutine 543 544! CHECK: func @_QMalloc_assignPtest_dyn_char_rhs_scalar( 545subroutine test_dyn_char_rhs_scalar(x, n) 546 integer :: n 547 character(n), allocatable :: x(:) 548 x = "Hello world!" 549 ! CHECK: fir.if %{{.*}} -> {{.*}} { 550 ! CHECK: fir.if %false -> {{.*}} { 551 ! CHECK: } 552 ! CHECK: } else { 553 ! TODO: runtime error if unallocated 554 ! CHECK-NOT: allocmem 555 ! CHECK: } 556end subroutine 557 558! Hit TODO: gathering lhs length in array expression 559!subroutine test_deferred_char(x, c) 560! character(:), allocatable :: x(:) 561! character(12) :: c(20) 562! x = "Hello world!" 563!end subroutine 564 565! CHECK-LABEL: func @_QMalloc_assignPtest_cst_char( 566! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>>{{.*}}, 567! CHECK-SAME: %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 568subroutine test_cst_char(x, c) 569 character(10), allocatable :: x(:) 570 character(12) :: c(20) 571! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 572! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<20x!fir.char<1,12>>> 573! CHECK: %[[VAL_4_0:.*]] = arith.constant 20 : index 574! CHECK: %[[VAL_4:.*]] = arith.constant 20 : index 575! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4_0]] : (index) -> !fir.shape<1> 576! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>> 577! 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>>> 578! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> i64 579! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64 580! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_10]] : i64 581! CHECK: %[[VAL_12:.*]]:2 = fir.if %[[VAL_11]] -> (i1, !fir.heap<!fir.array<?x!fir.char<1,10>>>) { 582! CHECK: %[[VAL_13:.*]] = arith.constant false 583! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 584! 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) 585! CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_15]]#1, %[[VAL_4]] : index 586! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_16]], %[[VAL_16]], %[[VAL_13]] : i1 587! CHECK: %[[VAL_18:.*]] = fir.if %[[VAL_17]] -> (!fir.heap<!fir.array<?x!fir.char<1,10>>>) { 588! CHECK: %[[VAL_19:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_4]] {uniq_name = ".auto.alloc"} 589! CHECK: fir.result %[[VAL_19]] : !fir.heap<!fir.array<?x!fir.char<1,10>>> 590! CHECK: } else { 591! CHECK: fir.result %[[VAL_8]] : !fir.heap<!fir.array<?x!fir.char<1,10>>> 592! CHECK: } 593! CHECK: fir.result %[[VAL_17]], %[[VAL_20:.*]] : i1, !fir.heap<!fir.array<?x!fir.char<1,10>>> 594! CHECK: } else { 595! CHECK: %[[VAL_21:.*]] = arith.constant true 596! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_4]] {uniq_name = ".auto.alloc"} 597! CHECK: fir.result %[[VAL_21]], %[[VAL_22]] : i1, !fir.heap<!fir.array<?x!fir.char<1,10>>> 598! CHECK: } 599 600! CHECK: %[[VAL_23:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 601! 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>> 602! 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>>> 603! CHECK: fir.if %[[VAL_12]]#0 { 604! CHECK: fir.if %[[VAL_11]] { 605! CHECK: fir.freemem %[[VAL_8]] 606! CHECK: } 607! CHECK: %[[VAL_36:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 608! 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>>>> 609! CHECK: fir.store %[[VAL_37]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>> 610! CHECK: } 611 x = c 612end subroutine 613 614! CHECK-LABEL: func @_QMalloc_assignPtest_dyn_char( 615! 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>{{.*}}) { 616subroutine test_dyn_char(x, n, c) 617 integer :: n 618 character(n), allocatable :: x(:) 619 character(*) :: c(20) 620! CHECK: %[[VAL_3:.*]]:2 = fir.unboxchar %[[VAL_2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 621! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<20x!fir.char<1,?>>> 622! CHECK: %[[VAL_5_0:.*]] = arith.constant 20 : index 623! CHECK: %[[VAL_6A:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32> 624! CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32 625! CHECK: %[[VAL_6B:.*]] = arith.cmpi sgt, %[[VAL_6A]], %[[c0_i32]] : i32 626! CHECK: %[[VAL_6:.*]] = arith.select %[[VAL_6B]], %[[VAL_6A]], %[[c0_i32]] : i32 627! CHECK: %[[VAL_5:.*]] = arith.constant 20 : index 628! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_5_0]] : (index) -> !fir.shape<1> 629! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>> 630! 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,?>>> 631! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> i64 632! CHECK: %[[VAL_12:.*]] = arith.constant 0 : i64 633! CHECK: %[[VAL_13:.*]] = arith.cmpi ne, %[[VAL_11]], %[[VAL_12]] : i64 634! CHECK: %[[VAL_14:.*]]:2 = fir.if %[[VAL_13]] -> (i1, !fir.heap<!fir.array<?x!fir.char<1,?>>>) { 635! CHECK: %[[VAL_15:.*]] = arith.constant false 636! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index 637! 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) 638! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_17]]#1, %[[VAL_5]] : index 639! CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_18]], %[[VAL_15]] : i1 640! CHECK: %[[VAL_20:.*]] = fir.if %[[VAL_19]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) { 641! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 642! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_21]] : index), %[[VAL_5]] {uniq_name = ".auto.alloc"} 643! CHECK: fir.result %[[VAL_22]] : !fir.heap<!fir.array<?x!fir.char<1,?>>> 644! CHECK: } else { 645! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?x!fir.char<1,?>>> 646! CHECK: } 647! CHECK: fir.result %[[VAL_19]], %[[VAL_23:.*]] : i1, !fir.heap<!fir.array<?x!fir.char<1,?>>> 648! CHECK: } else { 649! CHECK: %[[VAL_24:.*]] = arith.constant true 650! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 651! CHECK: %[[VAL_26:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_25]] : index), %[[VAL_5]] {uniq_name = ".auto.alloc"} 652! CHECK: fir.result %[[VAL_24]], %[[VAL_26]] : i1, !fir.heap<!fir.array<?x!fir.char<1,?>>> 653! CHECK: } 654 655! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 656! 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,?>> 657! normal array assignment .... 658! 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 659 660! CHECK: fir.if %[[VAL_14]]#0 { 661! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 662! CHECK: fir.if %[[VAL_13]] { 663! CHECK: fir.freemem %[[VAL_10]] 664! CHECK: } 665! CHECK: %[[VAL_40:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 666! 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,?>>>> 667! CHECK: fir.store %[[VAL_41]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>> 668! CHECK: } 669 x = c 670end subroutine 671 672! CHECK-LABEL: func @_QMalloc_assignPtest_derived_with_init 673subroutine test_derived_with_init(x, y) 674 type t 675 integer, allocatable :: a(:) 676 end type 677 type(t), allocatable :: x 678 type(t) :: y 679 ! The allocatable component of `x` need to be initialized 680 ! during the automatic allocation (setting its rank and allocation 681 ! status) before it is assigned with the component of `y` 682 x = y 683! CHECK: fir.if %{{.*}} { 684! CHECK: %[[VAL_11:.*]] = fir.allocmem !fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}> {uniq_name = ".auto.alloc"} 685! 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>>>}>>> 686! 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> 687! CHECK: fir.call @_FortranAInitialize(%[[VAL_15]], %{{.*}}, %{{.*}}) : (!fir.box<none>, !fir.ref<i8>, i32) -> none 688! CHECK: fir.result %[[VAL_11]] : !fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>> 689! CHECK: } else { 690! CHECK: fir.result %{{.*}} : !fir.heap<!fir.type<_QMalloc_assignFtest_derived_with_initTt{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>> 691! CHECK: } 692end subroutine 693 694! CHECK-LABEL: func @_QMalloc_assignPtest_vector_subscript( 695! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {fir.bindc_name = "x"}, 696! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "y"}, 697! CHECK-SAME: %[[VAL_2:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "v"}) { 698subroutine test_vector_subscript(x, y, v) 699 ! Test that the new shape is computed correctly in presence of 700 ! vector subscripts on the RHS and that it is used to allocate 701 ! the new storage and to drive the implicit loop. 702 integer, allocatable :: x(:) 703 integer :: y(:), v(:) 704 x = y(v) 705! CHECK: %[[VAL_3:.*]] = arith.constant 1 : index 706! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index 707! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_4]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 708! CHECK: %[[VAL_6:.*]] = arith.constant 0 : index 709! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_6]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 710! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_2]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32> 711! CHECK: %[[VAL_9:.*]] = arith.cmpi sgt, %[[VAL_7]]#1, %[[VAL_5]]#1 : index 712! CHECK: %[[VAL_10:.*]] = arith.select %[[VAL_9]], %[[VAL_5]]#1, %[[VAL_7]]#1 : index 713! CHECK: fir.if {{.*}} { 714! CHECK: %[[VAL_18:.*]] = arith.constant false 715! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) 716! CHECK: %[[VAL_21:.*]] = arith.cmpi ne, %[[VAL_20]]#1, %[[VAL_10]] : index 717! CHECK: %[[VAL_22:.*]] = arith.select %[[VAL_21]], %[[VAL_21]], %[[VAL_18]] : i1 718! CHECK: fir.if %[[VAL_22]] {{.*}} { 719! CHECK: %[[VAL_24:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]] {uniq_name = ".auto.alloc"} 720! CHECK: fir.result %[[VAL_24]] : !fir.heap<!fir.array<?xi32>> 721! CHECK: } else { 722! CHECK: fir.result %{{.*}} : !fir.heap<!fir.array<?xi32>> 723! CHECK: } 724! CHECK: fir.result %{{.*}}, %{{.*}} 725! CHECK: } else { 726! CHECK: %[[VAL_27:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]] {uniq_name = ".auto.alloc"} 727! CHECK: fir.result %{{.*}}, %[[VAL_27]] : i1, !fir.heap<!fir.array<?xi32>> 728! CHECK: } 729! CHECK: %[[VAL_28:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1> 730! CHECK: %[[VAL_29:.*]] = fir.array_load %[[VAL_30:.*]]#1(%[[VAL_28]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.array<?xi32> 731! CHECK: %[[VAL_31:.*]] = arith.constant 1 : index 732! CHECK: %[[VAL_32:.*]] = arith.constant 0 : index 733! CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_10]], %[[VAL_31]] : index 734! CHECK: %[[VAL_34:.*]] = fir.do_loop %[[VAL_35:.*]] = %[[VAL_32]] to %[[VAL_33]] step %[[VAL_31]] {{.*}} { 735! CHECK: } 736end subroutine 737 738! CHECK: fir.global linkonce @[[error_message]] constant : !fir.char<1,76> { 739! 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> 740! CHECK: fir.has_value %[[msg:.*]] : !fir.char<1,76> 741! CHECK: } 742 743end module 744 745! use alloc_assign 746! real :: y(2, 3) = reshape([1,2,3,4,5,6], [2,3]) 747! real, allocatable :: x (:, :) 748! allocate(x(2,2)) 749! call test_with_lbounds(x, y) 750! print *, x(10, 20) 751! print *, x 752!end 753