1! Test allocatable assignments 2! RUN: bbc -emit-fir %s -o - | FileCheck %s 3 4module alloc_assign 5contains 6 7! ----------------------------------------------------------------------------- 8! Test simple scalar RHS 9! ----------------------------------------------------------------------------- 10 11! CHECK-LABEL: func @_QMalloc_assignPtest_simple_scalar( 12! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<f32>>>{{.*}}) { 13subroutine test_simple_scalar(x) 14 real, allocatable :: x 15! CHECK: %[[VAL_1:.*]] = arith.constant 4.200000e+01 : f32 16! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<f32>>> 17! CHECK: %[[VAL_3:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32> 18! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<f32>) -> i64 19! CHECK: %[[VAL_5:.*]] = arith.constant 0 : i64 20! CHECK: %[[VAL_6:.*]] = arith.cmpi ne, %[[VAL_4]], %[[VAL_5]] : i64 21! CHECK: %[[VAL_7:.*]]:2 = fir.if %[[VAL_6]] -> (i1, !fir.heap<f32>) { 22! CHECK: %[[VAL_8:.*]] = arith.constant false 23! CHECK: %[[VAL_9:.*]] = fir.if %[[VAL_8]] -> (!fir.heap<f32>) { 24! CHECK: %[[VAL_10:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 25! CHECK: fir.result %[[VAL_10]] : !fir.heap<f32> 26! CHECK: } else { 27! CHECK: fir.result %[[VAL_3]] : !fir.heap<f32> 28! CHECK: } 29! CHECK: fir.result %[[VAL_8]], %[[VAL_11:.*]] : i1, !fir.heap<f32> 30! CHECK: } else { 31! CHECK: %[[VAL_12:.*]] = arith.constant true 32! CHECK: %[[VAL_13:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 33! CHECK: fir.result %[[VAL_12]], %[[VAL_13]] : i1, !fir.heap<f32> 34! CHECK: } 35! CHECK: fir.store %[[VAL_1]] to %[[VAL_14:.*]]#1 : !fir.heap<f32> 36! CHECK: fir.if %[[VAL_14]]#0 { 37! CHECK: fir.if %[[VAL_6]] { 38! CHECK: fir.freemem %[[VAL_3]] 39! CHECK: } 40! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_14]]#1 : (!fir.heap<f32>) -> !fir.box<!fir.heap<f32>> 41! CHECK: fir.store %[[VAL_15]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<f32>>> 42! CHECK: } 43 x = 42. 44end subroutine 45 46! CHECK-LABEL: func @_QMalloc_assignPtest_simple_local_scalar() { 47subroutine test_simple_local_scalar() 48 real, allocatable :: x 49! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.heap<f32> {uniq_name = "_QMalloc_assignFtest_simple_local_scalarEx.addr"} 50! CHECK: %[[VAL_2:.*]] = fir.zero_bits !fir.heap<f32> 51! CHECK: fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<!fir.heap<f32>> 52! CHECK: %[[VAL_3:.*]] = arith.constant 4.200000e+01 : f32 53! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.heap<f32>> 54! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (!fir.heap<f32>) -> i64 55! CHECK: %[[VAL_6:.*]] = arith.constant 0 : i64 56! CHECK: %[[VAL_7:.*]] = arith.cmpi ne, %[[VAL_5]], %[[VAL_6]] : i64 57! CHECK: %[[VAL_8:.*]]:2 = fir.if %[[VAL_7]] -> (i1, !fir.heap<f32>) { 58! CHECK: %[[VAL_9:.*]] = arith.constant false 59! CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.heap<f32>) { 60! CHECK: %[[VAL_11:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 61! CHECK: fir.result %[[VAL_11]] : !fir.heap<f32> 62! CHECK: } else { 63! CHECK: fir.result %[[VAL_4]] : !fir.heap<f32> 64! CHECK: } 65! CHECK: fir.result %[[VAL_9]], %[[VAL_12:.*]] : i1, !fir.heap<f32> 66! CHECK: } else { 67! CHECK: %[[VAL_13:.*]] = arith.constant true 68! CHECK: %[[VAL_14:.*]] = fir.allocmem f32 {uniq_name = ".auto.alloc"} 69! CHECK: fir.result %[[VAL_13]], %[[VAL_14]] : i1, !fir.heap<f32> 70! CHECK: } 71! CHECK: fir.store %[[VAL_3]] to %[[VAL_15:.*]]#1 : !fir.heap<f32> 72! CHECK: fir.if %[[VAL_15]]#0 { 73! CHECK: fir.if %[[VAL_7]] { 74! CHECK: fir.freemem %[[VAL_4]] 75! CHECK: } 76! CHECK: fir.store %[[VAL_15]]#1 to %[[VAL_1]] : !fir.ref<!fir.heap<f32>> 77! CHECK: } 78 x = 42. 79end subroutine 80 81! ----------------------------------------------------------------------------- 82! Test character scalar RHS 83! ----------------------------------------------------------------------------- 84 85! CHECK-LABEL: func @_QMalloc_assignPtest_deferred_char_scalar( 86! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>{{.*}}) { 87subroutine test_deferred_char_scalar(x) 88 character(:), allocatable :: x 89! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QQ{{.*}}) : !fir.ref<!fir.char<1,12>> 90! CHECK: %[[VAL_2:.*]] = arith.constant 12 : index 91! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 92! CHECK: %[[VAL_4:.*]] = fir.box_addr %[[VAL_3]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> !fir.heap<!fir.char<1,?>> 93! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (!fir.heap<!fir.char<1,?>>) -> i64 94! CHECK: %[[VAL_6:.*]] = arith.constant 0 : i64 95! CHECK: %[[VAL_7:.*]] = arith.cmpi ne, %[[VAL_5]], %[[VAL_6]] : i64 96! CHECK: %[[VAL_8:.*]]:2 = fir.if %[[VAL_7]] -> (i1, !fir.heap<!fir.char<1,?>>) { 97! CHECK: %[[VAL_9:.*]] = arith.constant false 98! CHECK: %[[VAL_10:.*]] = fir.box_elesize %[[VAL_3]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> index 99! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_10]], %[[VAL_2]] : index 100! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_11]], %[[VAL_11]], %[[VAL_9]] : i1 101! CHECK: %[[VAL_13:.*]] = fir.if %[[VAL_12]] -> (!fir.heap<!fir.char<1,?>>) { 102! CHECK: %[[VAL_14:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_2]] : index) {uniq_name = ".auto.alloc"} 103! CHECK: fir.result %[[VAL_14]] : !fir.heap<!fir.char<1,?>> 104! CHECK: } else { 105! CHECK: fir.result %[[VAL_4]] : !fir.heap<!fir.char<1,?>> 106! CHECK: } 107! CHECK: fir.result %[[VAL_12]], %[[VAL_15:.*]] : i1, !fir.heap<!fir.char<1,?>> 108! CHECK: } else { 109! CHECK: %[[VAL_16:.*]] = arith.constant true 110! CHECK: %[[VAL_17:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_2]] : index) {uniq_name = ".auto.alloc"} 111! CHECK: fir.result %[[VAL_16]], %[[VAL_17]] : i1, !fir.heap<!fir.char<1,?>> 112! CHECK: } 113 114! character assignment ... 115! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_8]]#1 : (!fir.heap<!fir.char<1,?>>) -> !fir.ref<i8> 116! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_24]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 117! character assignment ... 118 119! CHECK: fir.if %[[VAL_8]]#0 { 120! CHECK: fir.if %[[VAL_7]] { 121! CHECK: fir.freemem %[[VAL_4]] 122! CHECK: } 123! CHECK: %[[VAL_36:.*]] = fir.embox %[[VAL_8]]#1 typeparams %[[VAL_2]] : (!fir.heap<!fir.char<1,?>>, index) -> !fir.box<!fir.heap<!fir.char<1,?>>> 124! CHECK: fir.store %[[VAL_36]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 125! CHECK: } 126 x = "Hello world!" 127end subroutine 128 129! CHECK-LABEL: func @_QMalloc_assignPtest_cst_char_scalar( 130! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>>{{.*}}) { 131subroutine test_cst_char_scalar(x) 132 character(10), allocatable :: x 133! CHECK: %[[VAL_1:.*]] = arith.constant 10 : index 134! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QQ{{.*}}) : !fir.ref<!fir.char<1,12>> 135! CHECK: %[[VAL_3:.*]] = arith.constant 12 : index 136! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>> 137! CHECK: %[[VAL_5:.*]] = fir.box_addr %[[VAL_4]] : (!fir.box<!fir.heap<!fir.char<1,10>>>) -> !fir.heap<!fir.char<1,10>> 138! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (!fir.heap<!fir.char<1,10>>) -> i64 139! CHECK: %[[VAL_7:.*]] = arith.constant 0 : i64 140! CHECK: %[[VAL_8:.*]] = arith.cmpi ne, %[[VAL_6]], %[[VAL_7]] : i64 141! CHECK: %[[VAL_9:.*]]:2 = fir.if %[[VAL_8]] -> (i1, !fir.heap<!fir.char<1,10>>) { 142! CHECK: %[[VAL_10:.*]] = arith.constant false 143! CHECK: %[[VAL_11:.*]] = fir.if %[[VAL_10]] -> (!fir.heap<!fir.char<1,10>>) { 144! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.char<1,10> {uniq_name = ".auto.alloc"} 145! CHECK: fir.result %[[VAL_12]] : !fir.heap<!fir.char<1,10>> 146! CHECK: } else { 147! CHECK: fir.result %[[VAL_5]] : !fir.heap<!fir.char<1,10>> 148! CHECK: } 149! CHECK: fir.result %[[VAL_10]], %[[VAL_13:.*]] : i1, !fir.heap<!fir.char<1,10>> 150! CHECK: } else { 151! CHECK: %[[VAL_14:.*]] = arith.constant true 152! CHECK: %[[VAL_15:.*]] = fir.allocmem !fir.char<1,10> {uniq_name = ".auto.alloc"} 153! CHECK: fir.result %[[VAL_14]], %[[VAL_15]] : i1, !fir.heap<!fir.char<1,10>> 154! CHECK: } 155 156! character assignment ... 157! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_9]]#1 : (!fir.heap<!fir.char<1,10>>) -> !fir.ref<i8> 158! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_24]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 159! character assignment ... 160 161! CHECK: fir.if %[[VAL_9]]#0 { 162! CHECK: fir.if %[[VAL_8]] { 163! CHECK: fir.freemem %[[VAL_5]] 164! CHECK: } 165! CHECK: %[[VAL_34:.*]] = fir.embox %[[VAL_9]]#1 : (!fir.heap<!fir.char<1,10>>) -> !fir.box<!fir.heap<!fir.char<1,10>>> 166! CHECK: fir.store %[[VAL_34]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,10>>>> 167! CHECK: } 168 x = "Hello world!" 169end subroutine 170 171! CHECK-LABEL: func @_QMalloc_assignPtest_dyn_char_scalar( 172! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>{{.*}}, 173! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32>{{.*}}) { 174subroutine test_dyn_char_scalar(x, n) 175 integer :: n 176 character(n), allocatable :: x 177! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32> 178! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QQcl.48656C6C6F20776F726C6421) : !fir.ref<!fir.char<1,12>> 179! CHECK: %[[VAL_4:.*]] = arith.constant 12 : index 180! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 181! CHECK: %[[VAL_6:.*]] = fir.box_addr %[[VAL_5]] : (!fir.box<!fir.heap<!fir.char<1,?>>>) -> !fir.heap<!fir.char<1,?>> 182! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (!fir.heap<!fir.char<1,?>>) -> i64 183! CHECK: %[[VAL_8:.*]] = arith.constant 0 : i64 184! CHECK: %[[VAL_9:.*]] = arith.cmpi ne, %[[VAL_7]], %[[VAL_8]] : i64 185! CHECK: %[[VAL_10:.*]]:2 = fir.if %[[VAL_9]] -> (i1, !fir.heap<!fir.char<1,?>>) { 186! CHECK: %[[VAL_11:.*]] = arith.constant false 187! CHECK: %[[VAL_12:.*]] = fir.if %[[VAL_11]] -> (!fir.heap<!fir.char<1,?>>) { 188! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_2]] : (i32) -> index 189! CHECK: %[[VAL_14:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_13]] : index) {uniq_name = ".auto.alloc"} 190! CHECK: fir.result %[[VAL_14]] : !fir.heap<!fir.char<1,?>> 191! CHECK: } else { 192! CHECK: fir.result %[[VAL_6]] : !fir.heap<!fir.char<1,?>> 193! CHECK: } 194! CHECK: fir.result %[[VAL_11]], %[[VAL_15:.*]] : i1, !fir.heap<!fir.char<1,?>> 195! CHECK: } else { 196! CHECK: %[[VAL_16:.*]] = arith.constant true 197! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_2]] : (i32) -> index 198! CHECK: %[[VAL_18:.*]] = fir.allocmem !fir.char<1,?>(%[[VAL_17]] : index) {uniq_name = ".auto.alloc"} 199! CHECK: fir.result %[[VAL_16]], %[[VAL_18]] : i1, !fir.heap<!fir.char<1,?>> 200! CHECK: } 201 202! character assignment ... 203! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_10]]#1 : (!fir.heap<!fir.char<1,?>>) -> !fir.ref<i8> 204! CHECK: fir.call @llvm.memmove.p0i8.p0i8.i64(%[[VAL_24]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 205! character assignment ... 206 207! CHECK: fir.if %[[VAL_10]]#0 { 208! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_2]] : (i32) -> index 209! CHECK: fir.if %[[VAL_9]] { 210! CHECK: fir.freemem %[[VAL_6]] 211! CHECK: } 212! CHECK: %[[VAL_40:.*]] = fir.embox %[[VAL_10]]#1 typeparams %[[VAL_39]] : (!fir.heap<!fir.char<1,?>>, index) -> !fir.box<!fir.heap<!fir.char<1,?>>> 213! CHECK: fir.store %[[VAL_40]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>> 214! CHECK: } 215 x = "Hello world!" 216end subroutine 217 218! ----------------------------------------------------------------------------- 219! Test numeric/logical array RHS 220! ----------------------------------------------------------------------------- 221 222! CHECK-LABEL: func @_QMalloc_assignPtest_from_cst_shape_array( 223! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 224! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.array<2x3xf32>>{{.*}}) { 225subroutine test_from_cst_shape_array(x, y) 226 real, allocatable :: x(:, :) 227 real :: y(2, 3) 228! CHECK: %[[VAL_2_0:.*]] = arith.constant 2 : index 229! CHECK: %[[VAL_3_0:.*]] = arith.constant 3 : index 230! CHECK: %[[VAL_2:.*]] = arith.constant 2 : index 231! CHECK: %[[VAL_3:.*]] = arith.constant 3 : index 232! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 233! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_6]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 234! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 235! CHECK: %[[VAL_9:.*]] = arith.constant 0 : i64 236! CHECK: %[[VAL_10:.*]] = arith.cmpi ne, %[[VAL_8]], %[[VAL_9]] : i64 237! CHECK: %[[VAL_11:.*]]:2 = fir.if %[[VAL_10]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 238! CHECK: %[[VAL_12:.*]] = arith.constant false 239! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index 240! CHECK: %[[VAL_14:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_13]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 241! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index 242! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_15]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 243! CHECK: %[[VAL_17:.*]] = arith.cmpi ne, %[[VAL_14]]#1, %[[VAL_2]] : index 244! CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_17]], %[[VAL_12]] : i1 245! CHECK: %[[VAL_19:.*]] = arith.cmpi ne, %[[VAL_16]]#1, %[[VAL_3]] : index 246! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_19]], %[[VAL_18]] : i1 247! CHECK: %[[VAL_21:.*]] = fir.if %[[VAL_20]] -> (!fir.heap<!fir.array<?x?xf32>>) { 248! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_2]], %[[VAL_3]] {uniq_name = ".auto.alloc"} 249! CHECK: fir.result %[[VAL_22]] : !fir.heap<!fir.array<?x?xf32>> 250! CHECK: } else { 251! CHECK: fir.result %[[VAL_7]] : !fir.heap<!fir.array<?x?xf32>> 252! CHECK: } 253! CHECK: fir.result %[[VAL_20]], %[[VAL_23:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 254! CHECK: } else { 255! CHECK: %[[VAL_24:.*]] = arith.constant true 256! CHECK: %[[VAL_25:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_2]], %[[VAL_3]] {uniq_name = ".auto.alloc"} 257! CHECK: fir.result %[[VAL_24]], %[[VAL_25]] : i1, !fir.heap<!fir.array<?x?xf32>> 258! CHECK: } 259 260! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 261! CHECK: %[[VAL_27:.*]] = fir.array_load %[[VAL_11]]#1(%[[VAL_26]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 262! normal array assignment .... 263! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_11]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 264 265! CHECK: fir.if %[[VAL_11]]#0 { 266! CHECK: fir.if %[[VAL_10]] { 267! CHECK: fir.freemem %[[VAL_7]] 268! CHECK: } 269! CHECK: %[[VAL_43:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 270! 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>>> 271! CHECK: fir.store %[[VAL_44]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 272! CHECK: } 273 x = y 274end subroutine 275 276! CHECK-LABEL: func @_QMalloc_assignPtest_from_dyn_shape_array( 277! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 278! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) { 279subroutine test_from_dyn_shape_array(x, y) 280 real, allocatable :: x(:, :) 281 real :: y(:, :) 282 x = y 283! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index 284! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_3]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 285! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index 286! CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_5]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 287! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 288! CHECK: %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 289! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 290! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64 291! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_10]] : i64 292! CHECK: %[[VAL_12:.*]]:2 = fir.if %[[VAL_11]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 293! CHECK: %[[VAL_13:.*]] = arith.constant false 294! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 295! CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_14]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 296! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index 297! CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_7]], %[[VAL_16]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 298! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_15]]#1, %[[VAL_4]]#1 : index 299! CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_18]], %[[VAL_13]] : i1 300! CHECK: %[[VAL_20:.*]] = arith.cmpi ne, %[[VAL_17]]#1, %[[VAL_6]]#1 : index 301! CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_20]], %[[VAL_19]] : i1 302! CHECK: %[[VAL_22:.*]] = fir.if %[[VAL_21]] -> (!fir.heap<!fir.array<?x?xf32>>) { 303! CHECK: %[[VAL_23:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_4]]#1, %[[VAL_6]]#1 {uniq_name = ".auto.alloc"} 304! CHECK: fir.result %[[VAL_23]] : !fir.heap<!fir.array<?x?xf32>> 305! CHECK: } else { 306! CHECK: fir.result %[[VAL_8]] : !fir.heap<!fir.array<?x?xf32>> 307! CHECK: } 308! CHECK: fir.result %[[VAL_21]], %[[VAL_24:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 309! CHECK: } else { 310! CHECK: %[[VAL_25:.*]] = arith.constant true 311! CHECK: %[[VAL_26:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_4]]#1, %[[VAL_6]]#1 {uniq_name = ".auto.alloc"} 312! CHECK: fir.result %[[VAL_25]], %[[VAL_26]] : i1, !fir.heap<!fir.array<?x?xf32>> 313! CHECK: } 314 315! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_4]]#1, %[[VAL_6]]#1 : (index, index) -> !fir.shape<2> 316! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_12]]#1(%[[VAL_27]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 317! normal array assignment .... 318! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_12]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 319 320! CHECK: fir.if %[[VAL_12]]#0 { 321! CHECK: fir.if %[[VAL_11]] { 322! CHECK: fir.freemem %[[VAL_8]] 323! CHECK: } 324! CHECK: %[[VAL_44:.*]] = fir.shape %[[VAL_4]]#1, %[[VAL_6]]#1 : (index, index) -> !fir.shape<2> 325! 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>>> 326! CHECK: fir.store %[[VAL_45]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 327! CHECK: } 328end subroutine 329 330! CHECK-LABEL: func @_QMalloc_assignPtest_with_lbounds( 331! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>{{.*}}, 332! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>>{{.*}}) { 333subroutine test_with_lbounds(x, y) 334 real, allocatable :: x(:, :) 335 real :: y(10:, 20:) 336! CHECK: %[[VAL_2:.*]] = arith.constant 10 : i64 337! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i64) -> index 338! CHECK: %[[VAL_4:.*]] = arith.constant 20 : i64 339! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i64) -> index 340! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index 341! CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_8]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 342! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index 343! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_1]], %[[VAL_10]] : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) 344! CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 345! CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_12]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>> 346! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (!fir.heap<!fir.array<?x?xf32>>) -> i64 347! CHECK: %[[VAL_15:.*]] = arith.constant 0 : i64 348! CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_14]], %[[VAL_15]] : i64 349! CHECK: %[[VAL_17:.*]]:2 = fir.if %[[VAL_16]] -> (i1, !fir.heap<!fir.array<?x?xf32>>) { 350! CHECK: %[[VAL_18:.*]] = arith.constant false 351! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index 352! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_12]], %[[VAL_19]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 353! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index 354! CHECK: %[[VAL_22:.*]]:3 = fir.box_dims %[[VAL_12]], %[[VAL_21]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index) 355! CHECK: %[[VAL_23:.*]] = arith.cmpi ne, %[[VAL_20]]#1, %[[VAL_9]]#1 : index 356! CHECK: %[[VAL_24:.*]] = arith.select %[[VAL_23]], %[[VAL_23]], %[[VAL_18]] : i1 357! CHECK: %[[VAL_25:.*]] = arith.cmpi ne, %[[VAL_22]]#1, %[[VAL_11]]#1 : index 358! CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_25]], %[[VAL_24]] : i1 359! CHECK: %[[VAL_27:.*]] = fir.if %[[VAL_26]] -> (!fir.heap<!fir.array<?x?xf32>>) { 360! CHECK: %[[VAL_28:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_9]]#1, %[[VAL_11]]#1 {uniq_name = ".auto.alloc"} 361! CHECK: fir.result %[[VAL_28]] : !fir.heap<!fir.array<?x?xf32>> 362! CHECK: } else { 363! CHECK: fir.result %[[VAL_13]] : !fir.heap<!fir.array<?x?xf32>> 364! CHECK: } 365! CHECK: fir.result %[[VAL_26]], %[[VAL_29:.*]] : i1, !fir.heap<!fir.array<?x?xf32>> 366! CHECK: } else { 367! CHECK: %[[VAL_30:.*]] = arith.constant true 368! CHECK: %[[VAL_31:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_9]]#1, %[[VAL_11]]#1 {uniq_name = ".auto.alloc"} 369! CHECK: fir.result %[[VAL_30]], %[[VAL_31]] : i1, !fir.heap<!fir.array<?x?xf32>> 370! CHECK: } 371 372! CHECK: %[[VAL_32:.*]] = fir.shape %[[VAL_9]]#1, %[[VAL_11]]#1 : (index, index) -> !fir.shape<2> 373! CHECK: %[[VAL_33:.*]] = fir.array_load %[[VAL_17]]#1(%[[VAL_32]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32> 374! normal array assignment .... 375! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[VAL_17]]#1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.heap<!fir.array<?x?xf32>> 376 377! CHECK: fir.if %[[VAL_17]]#0 { 378! CHECK: fir.if %[[VAL_16]] { 379! CHECK: fir.freemem %[[VAL_13]] 380! CHECK: } 381! CHECK: %[[VAL_49:.*]] = fir.shape_shift %[[VAL_3]], %[[VAL_9]]#1, %[[VAL_5]], %[[VAL_11]]#1 : (index, index, index, index) -> !fir.shapeshift<2> 382! 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>>> 383! CHECK: fir.store %[[VAL_50]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>> 384! CHECK: } 385 x = y 386end subroutine 387 388! CHECK-LABEL: func @_QMalloc_assignPtest_scalar_rhs( 389subroutine test_scalar_rhs(x, y) 390 real, allocatable :: x(:) 391 real :: y 392 ! CHECK: fir.if %{{.*}} -> {{.*}} { 393 ! CHECK: fir.if %false -> {{.*}} { 394 ! CHECK: } 395 ! CHECK: } else { 396 ! CHECK: %[[error_msg_addr:.*]] = fir.address_of(@[[error_message:.*]]) : !fir.ref<!fir.char<1,76>> 397 ! CHECK: %[[msg_addr_cast:.*]] = fir.convert %[[error_msg_addr]] : (!fir.ref<!fir.char<1,76>>) -> !fir.ref<i8> 398 ! CHECK: %15 = fir.call @_FortranAReportFatalUserError(%[[msg_addr_cast]], %{{.*}}, %{{.*}}) : (!fir.ref<i8>, !fir.ref<i8>, i32) -> none 399 ! CHECK-NOT: allocmem 400 ! CHECK: } 401 x = y 402end subroutine 403 404! ----------------------------------------------------------------------------- 405! Test character array RHS 406! ----------------------------------------------------------------------------- 407 408! CHECK: func @_QMalloc_assignPtest_cst_char_rhs_scalar( 409subroutine test_cst_char_rhs_scalar(x) 410 character(10), allocatable :: x(:) 411 x = "Hello world!" 412 ! CHECK: fir.if %{{.*}} -> {{.*}} { 413 ! CHECK: fir.if %false -> {{.*}} { 414 ! CHECK: } 415 ! CHECK: } else { 416 ! CHECK: fir.call @_FortranAReportFatalUserError 417 ! CHECK-NOT: allocmem 418 ! CHECK: } 419end subroutine 420 421! CHECK: func @_QMalloc_assignPtest_dyn_char_rhs_scalar( 422subroutine test_dyn_char_rhs_scalar(x, n) 423 integer :: n 424 character(n), allocatable :: x(:) 425 x = "Hello world!" 426 ! CHECK: fir.if %{{.*}} -> {{.*}} { 427 ! CHECK: fir.if %false -> {{.*}} { 428 ! CHECK: } 429 ! CHECK: } else { 430 ! CHECK: fir.call @_FortranAReportFatalUserError 431 ! CHECK-NOT: allocmem 432 ! CHECK: } 433end subroutine 434 435! CHECK-LABEL: func @_QMalloc_assignPtest_cst_char( 436! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>>{{.*}}, 437! CHECK-SAME: %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 438subroutine test_cst_char(x, c) 439 character(10), allocatable :: x(:) 440 character(12) :: c(20) 441! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 442! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<20x!fir.char<1,12>>> 443! CHECK: %[[VAL_4_0:.*]] = arith.constant 20 : index 444! CHECK: %[[VAL_4:.*]] = arith.constant 20 : index 445! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4_0]] : (index) -> !fir.shape<1> 446! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>> 447! 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>>> 448! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> i64 449! CHECK: %[[VAL_10:.*]] = arith.constant 0 : i64 450! CHECK: %[[VAL_11:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_10]] : i64 451! CHECK: %[[VAL_12:.*]]:2 = fir.if %[[VAL_11]] -> (i1, !fir.heap<!fir.array<?x!fir.char<1,10>>>) { 452! CHECK: %[[VAL_13:.*]] = arith.constant false 453! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 454! 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) 455! CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_15]]#1, %[[VAL_4]] : index 456! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_16]], %[[VAL_16]], %[[VAL_13]] : i1 457! CHECK: %[[VAL_18:.*]] = fir.if %[[VAL_17]] -> (!fir.heap<!fir.array<?x!fir.char<1,10>>>) { 458! CHECK: %[[VAL_19:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_4]] {uniq_name = ".auto.alloc"} 459! CHECK: fir.result %[[VAL_19]] : !fir.heap<!fir.array<?x!fir.char<1,10>>> 460! CHECK: } else { 461! CHECK: fir.result %[[VAL_8]] : !fir.heap<!fir.array<?x!fir.char<1,10>>> 462! CHECK: } 463! CHECK: fir.result %[[VAL_17]], %[[VAL_20:.*]] : i1, !fir.heap<!fir.array<?x!fir.char<1,10>>> 464! CHECK: } else { 465! CHECK: %[[VAL_21:.*]] = arith.constant true 466! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_4]] {uniq_name = ".auto.alloc"} 467! CHECK: fir.result %[[VAL_21]], %[[VAL_22]] : i1, !fir.heap<!fir.array<?x!fir.char<1,10>>> 468! CHECK: } 469 470! CHECK: %[[VAL_23:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 471! 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>> 472! 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>>> 473! CHECK: fir.if %[[VAL_12]]#0 { 474! CHECK: fir.if %[[VAL_11]] { 475! CHECK: fir.freemem %[[VAL_8]] 476! CHECK: } 477! CHECK: %[[VAL_36:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 478! 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>>>> 479! CHECK: fir.store %[[VAL_37]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>> 480! CHECK: } 481 x = c 482end subroutine 483 484! CHECK-LABEL: func @_QMalloc_assignPtest_dyn_char( 485! 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>{{.*}}) { 486subroutine test_dyn_char(x, n, c) 487 integer :: n 488 character(n), allocatable :: x(:) 489 character(*) :: c(20) 490! CHECK: %[[VAL_3:.*]]:2 = fir.unboxchar %[[VAL_2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 491! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<20x!fir.char<1,?>>> 492! CHECK: %[[VAL_5_0:.*]] = arith.constant 20 : index 493! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32> 494! CHECK: %[[VAL_5:.*]] = arith.constant 20 : index 495! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_5_0]] : (index) -> !fir.shape<1> 496! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>> 497! 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,?>>> 498! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.heap<!fir.array<?x!fir.char<1,?>>>) -> i64 499! CHECK: %[[VAL_12:.*]] = arith.constant 0 : i64 500! CHECK: %[[VAL_13:.*]] = arith.cmpi ne, %[[VAL_11]], %[[VAL_12]] : i64 501! CHECK: %[[VAL_14:.*]]:2 = fir.if %[[VAL_13]] -> (i1, !fir.heap<!fir.array<?x!fir.char<1,?>>>) { 502! CHECK: %[[VAL_15:.*]] = arith.constant false 503! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index 504! 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) 505! CHECK: %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_17]]#1, %[[VAL_5]] : index 506! CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_18]], %[[VAL_15]] : i1 507! CHECK: %[[VAL_20:.*]] = fir.if %[[VAL_19]] -> (!fir.heap<!fir.array<?x!fir.char<1,?>>>) { 508! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 509! CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_21]] : index), %[[VAL_5]] {uniq_name = ".auto.alloc"} 510! CHECK: fir.result %[[VAL_22]] : !fir.heap<!fir.array<?x!fir.char<1,?>>> 511! CHECK: } else { 512! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?x!fir.char<1,?>>> 513! CHECK: } 514! CHECK: fir.result %[[VAL_19]], %[[VAL_23:.*]] : i1, !fir.heap<!fir.array<?x!fir.char<1,?>>> 515! CHECK: } else { 516! CHECK: %[[VAL_24:.*]] = arith.constant true 517! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 518! CHECK: %[[VAL_26:.*]] = fir.allocmem !fir.array<?x!fir.char<1,?>>(%[[VAL_25]] : index), %[[VAL_5]] {uniq_name = ".auto.alloc"} 519! CHECK: fir.result %[[VAL_24]], %[[VAL_26]] : i1, !fir.heap<!fir.array<?x!fir.char<1,?>>> 520! CHECK: } 521 522! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 523! 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,?>> 524! normal array assignment .... 525! 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 526 527! CHECK: fir.if %[[VAL_14]]#0 { 528! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_6]] : (i32) -> index 529! CHECK: fir.if %[[VAL_13]] { 530! CHECK: fir.freemem %[[VAL_10]] 531! CHECK: } 532! CHECK: %[[VAL_40:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 533! 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,?>>>> 534! CHECK: fir.store %[[VAL_41]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>> 535! CHECK: } 536 x = c 537end subroutine 538 539end module 540