1! RUN: bbc -emit-fir %s -o - | FileCheck %s 2 3! CHECK-LABEL: func @_QPtest1 4subroutine test1(a,b,c,n) 5 integer :: n 6 real, intent(out) :: a(n) 7 real, intent(in) :: b(n), c(n) 8 ! CHECK-DAG: %[[A:.*]] = fir.array_load %arg0(% 9 ! CHECK-DAG: %[[B:.*]] = fir.array_load %arg1(% 10 ! CHECK-DAG: %[[C:.*]] = fir.array_load %arg2(% 11 ! CHECK: %[[T:.*]] = fir.do_loop 12 ! CHECK-DAG: %[[Bi:.*]] = fir.array_fetch %[[B]] 13 ! CHECK-DAG: %[[Ci:.*]] = fir.array_fetch %[[C]] 14 ! CHECK: %[[rv:.*]] = arith.addf %[[Bi]], %[[Ci]] 15 ! CHECK: fir.array_update %{{.*}}, %[[rv]], % 16 a = b + c 17 ! CHECK: fir.array_merge_store %[[A]], %[[T]] to %arg0 18end subroutine test1 19 20! CHECK-LABEL: func @_QPtest1b 21subroutine test1b(a,b,c,d,n) 22 integer :: n 23 real, intent(out) :: a(n) 24 real, intent(in) :: b(n), c(n), d(n) 25 ! CHECK-DAG: %[[A:.*]] = fir.array_load %arg0(% 26 ! CHECK-DAG: %[[B:.*]] = fir.array_load %arg1(% 27 ! CHECK-DAG: %[[C:.*]] = fir.array_load %arg2(% 28 ! CHECK-DAG: %[[D:.*]] = fir.array_load %arg3(% 29 ! CHECK: %[[T:.*]] = fir.do_loop 30 ! CHECK-DAG: %[[Bi:.*]] = fir.array_fetch %[[B]] 31 ! CHECK-DAG: %[[Ci:.*]] = fir.array_fetch %[[C]] 32 ! CHECK: %[[rv1:.*]] = arith.addf %[[Bi]], %[[Ci]] 33 ! CHECK: %[[Di:.*]] = fir.array_fetch %[[D]] 34 ! CHECK: %[[rv:.*]] = arith.addf %[[rv1]], %[[Di]] 35 ! CHECK: fir.array_update %{{.*}}, %[[rv]], % 36 a = b + c + d 37 ! CHECK: fir.array_merge_store %[[A]], %[[T]] to %arg0 38end subroutine test1b 39 40! CHECK-LABEL: func @_QPtest2( 41! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[VAL_2:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) { 42! CHECK: %[[VAL_3:.*]] = arith.constant 0 : index 43! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_3]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index) 44! CHECK: %[[VAL_5:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.array<?xf32> 45! CHECK: %[[VAL_6:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?xf32>>) -> !fir.array<?xf32> 46! CHECK: %[[VAL_7:.*]] = fir.array_load %[[VAL_2]] : (!fir.box<!fir.array<?xf32>>) -> !fir.array<?xf32> 47! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index 48! CHECK: %[[VAL_9:.*]] = arith.constant 0 : index 49! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_4]]#1, %[[VAL_8]] : index 50! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_5]]) -> (!fir.array<?xf32>) { 51! CHECK: %[[VAL_14:.*]] = fir.array_fetch %[[VAL_6]], %[[VAL_12]] : (!fir.array<?xf32>, index) -> f32 52! CHECK: %[[VAL_15:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_12]] : (!fir.array<?xf32>, index) -> f32 53! CHECK: %[[VAL_16:.*]] = arith.addf %[[VAL_14]], %[[VAL_15]] : f32 54! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_13]], %[[VAL_16]], %[[VAL_12]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32> 55! CHECK: fir.result %[[VAL_17]] : !fir.array<?xf32> 56! CHECK: } 57! CHECK: fir.array_merge_store %[[VAL_5]], %[[VAL_18:.*]] to %[[VAL_0]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.array<?xf32>> 58! CHECK: return 59! CHECK: } 60subroutine test2(a,b,c) 61 real, intent(out) :: a(:) 62 real, intent(in) :: b(:), c(:) 63 a = b + c 64end subroutine test2 65 66! CHECK-LABEL: func @_QPtest3 67subroutine test3(a,b,c,n) 68 integer :: n 69 real, intent(out) :: a(n) 70 real, intent(in) :: b(n), c 71 ! CHECK-DAG: %[[A:.*]] = fir.array_load %arg0(% 72 ! CHECK-DAG: %[[B:.*]] = fir.array_load %arg1(% 73 ! CHECK-DAG: %[[C:.*]] = fir.load %arg2 74 ! CHECK: %[[T:.*]] = fir.do_loop 75 ! CHECK: %[[Bi:.*]] = fir.array_fetch %[[B]] 76 ! CHECK: %[[rv:.*]] = arith.addf %[[Bi]], %[[C]] 77 ! CHECK: %[[Ti:.*]] = fir.array_update %{{.*}}, %[[rv]], % 78 ! CHECK: fir.result %[[Ti]] 79 a = b + c 80 ! CHECK: fir.array_merge_store %[[A]], %[[T]] to %arg0 81end subroutine test3 82 83! CHECK-LABEL: func @_QPtest4 84subroutine test4(a,b,c) 85! TODO: this declaration fails in CallInterface lowering 86! real, allocatable, intent(out) :: a(:) 87 real :: a(100) ! FIXME: fake it for now 88 real, intent(in) :: b(:), c 89 ! CHECK-DAG: %[[A:.*]] = fir.array_load %arg0(% 90 ! CHECK-DAG: %[[B:.*]] = fir.array_load %arg1 91 ! CHECK: fir.do_loop 92 ! CHECK: fir.array_fetch %[[B]], % 93 ! CHECK: fir.array_update 94 a = b + c 95 ! CHECK: fir.array_merge_store %[[A]], %{{.*}} to %arg0 96end subroutine test4 97 98! CHECK-LABEL: func @_QPtest5 99subroutine test5(a,b,c) 100! TODO: this declaration fails in CallInterface lowering 101! real, allocatable, intent(out) :: a(:) 102! real, pointer, intent(in) :: b(:) 103 real :: a(100), b(100) ! FIXME: fake it for now 104 real, intent(in) :: c 105 ! CHECK-DAG: %[[A:.*]] = fir.array_load %arg0(% 106 ! CHECK-DAG: %[[B:.*]] = fir.array_load %arg1(% 107 ! CHECK: fir.do_loop 108 ! CHECK: fir.array_fetch %[[B]], % 109 ! CHECK: fir.array_update 110 a = b + c 111 ! CHECK: fir.array_merge_store %[[A]], %{{.*}} to %arg0 112end subroutine test5 113 114! CHECK-LABEL: func @_QPtest6( 115! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<?xf32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<f32>{{.*}}, %[[VAL_3:.*]]: !fir.ref<i32>{{.*}}, %[[VAL_4:.*]]: !fir.ref<i32>{{.*}}) { 116! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> 117! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i32) -> i64 118! CHECK: %[[VAL_7A:.*]] = fir.convert %[[VAL_6]] : (i64) -> index 119! CHECK: %[[C0:.*]] = arith.constant 0 : index 120! CHECK: %[[CMP:.*]] = arith.cmpi sgt, %[[VAL_7A]], %[[C0]] : index 121! CHECK: %[[VAL_7:.*]] = arith.select %[[CMP]], %[[VAL_7A]], %[[C0]] : index 122! CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32> 123! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i32) -> i64 124! CHECK: %[[VAL_10A:.*]] = fir.convert %[[VAL_9]] : (i64) -> index 125! CHECK: %[[C0_2:.*]] = arith.constant 0 : index 126! CHECK: %[[CMP_2:.*]] = arith.cmpi sgt, %[[VAL_10A]], %[[C0_2]] : index 127! CHECK: %[[VAL_10:.*]] = arith.select %[[CMP_2]], %[[VAL_10A]], %[[C0_2]] : index 128! CHECK: %[[VAL_11:.*]] = arith.constant 3 : i64 129! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index 130! CHECK: %[[VAL_13:.*]] = arith.constant 4 : i64 131! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index 132! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> 133! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i32) -> i64 134! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i64) -> index 135! CHECK: %[[VAL_18:.*]] = arith.constant 0 : index 136! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_17]], %[[VAL_12]] : index 137! CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_19]], %[[VAL_14]] : index 138! CHECK: %[[VAL_21:.*]] = arith.divsi %[[VAL_20]], %[[VAL_14]] : index 139! CHECK: %[[VAL_22:.*]] = arith.cmpi sgt, %[[VAL_21]], %[[VAL_18]] : index 140! CHECK: %[[VAL_23:.*]] = arith.select %[[VAL_22]], %[[VAL_21]], %[[VAL_18]] : index 141! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1> 142! CHECK: %[[VAL_25:.*]] = fir.slice %[[VAL_12]], %[[VAL_17]], %[[VAL_14]] : (index, index, index) -> !fir.slice<1> 143! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_0]](%[[VAL_24]]) {{\[}}%[[VAL_25]]] : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<?xf32> 144! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1> 145! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_1]](%[[VAL_27]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> 146! CHECK: %[[VAL_29:.*]] = fir.load %[[VAL_2]] : !fir.ref<f32> 147! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index 148! CHECK: %[[VAL_31:.*]] = arith.constant 0 : index 149! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_23]], %[[VAL_30]] : index 150! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_26]]) -> (!fir.array<?xf32>) { 151! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_28]], %[[VAL_34]] : (!fir.array<?xf32>, index) -> f32 152! CHECK: %[[VAL_37:.*]] = arith.addf %[[VAL_36]], %[[VAL_29]] : f32 153! CHECK: %[[VAL_38:.*]] = fir.array_update %[[VAL_35]], %[[VAL_37]], %[[VAL_34]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32> 154! CHECK: fir.result %[[VAL_38]] : !fir.array<?xf32> 155! CHECK: } 156! CHECK: fir.array_merge_store %[[VAL_26]], %[[VAL_39:.*]] to %[[VAL_0]]{{\[}}%[[VAL_25]]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>, !fir.slice<1> 157! CHECK: return 158! CHECK: } 159 160subroutine test6(a,b,c,n,m) 161 integer :: n, m 162 real, intent(out) :: a(n) 163 real, intent(in) :: b(m), c 164 a(3:n:4) = b + c 165end subroutine test6 166 167! CHECK-LABEL: func @_QPtest6a( 168! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<10x50xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<10xf32>>{{.*}}) { 169! CHECK: %[[VAL_2:.*]] = arith.constant 10 : index 170! CHECK: %[[VAL_3:.*]] = arith.constant 50 : index 171! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index 172! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 173! CHECK: %[[VAL_6:.*]] = fir.array_load %[[VAL_1]](%[[VAL_5]]) : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> !fir.array<10xf32> 174! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index 175! CHECK: %[[VAL_8:.*]] = arith.constant 4 : i64 176! CHECK: %[[VAL_9:.*]] = fir.undefined index 177! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_8]] : (i64) -> index 178! CHECK: %[[VAL_11:.*]] = arith.subi %[[VAL_10]], %[[VAL_7]] : index 179! CHECK: %[[VAL_12:.*]] = arith.constant 41 : i64 180! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index 181! CHECK: %[[VAL_14:.*]] = arith.constant 1 : i64 182! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index 183! CHECK: %[[VAL_16:.*]] = arith.constant 50 : i64 184! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i64) -> index 185! CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 186! CHECK: %[[VAL_19:.*]] = fir.slice %[[VAL_8]], %[[VAL_9]], %[[VAL_9]], %[[VAL_13]], %[[VAL_17]], %[[VAL_15]] : (i64, index, index, index, index, index) -> !fir.slice<2> 187! CHECK: %[[VAL_20:.*]] = fir.array_load %[[VAL_0]](%[[VAL_18]]) {{\[}}%[[VAL_19]]] : (!fir.ref<!fir.array<10x50xf32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.array<10x50xf32> 188! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index 189! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index 190! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_4]], %[[VAL_21]] : index 191! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_6]]) -> (!fir.array<10xf32>) { 192! CHECK: %[[VAL_27:.*]] = fir.array_fetch %[[VAL_20]], %[[VAL_11]], %[[VAL_25]] : (!fir.array<10x50xf32>, index, index) -> f32 193! CHECK: %[[VAL_28:.*]] = fir.array_update %[[VAL_26]], %[[VAL_27]], %[[VAL_25]] : (!fir.array<10xf32>, f32, index) -> !fir.array<10xf32> 194! CHECK: fir.result %[[VAL_28]] : !fir.array<10xf32> 195! CHECK: } 196! CHECK: fir.array_merge_store %[[VAL_6]], %[[VAL_29:.*]] to %[[VAL_1]] : !fir.array<10xf32>, !fir.array<10xf32>, !fir.ref<!fir.array<10xf32>> 197! CHECK: return 198! CHECK: } 199 200subroutine test6a(a,b) 201 ! copy part of 1 row to b. a's projection has rank 1. 202 real :: a(10,50) 203 real :: b(10) 204 b = a(4,41:50) 205end subroutine test6a 206 207! CHECK-LABEL: func @_QPtest6b( 208! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<10x50xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<10xf32>>{{.*}}) { 209! CHECK: %[[VAL_2:.*]] = arith.constant 10 : index 210! CHECK: %[[VAL_3:.*]] = arith.constant 50 : index 211! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index 212! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index 213! CHECK: %[[VAL_6:.*]] = arith.constant 4 : i64 214! CHECK: %[[VAL_7:.*]] = fir.undefined index 215! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_6]] : (i64) -> index 216! CHECK: %[[VAL_9:.*]] = arith.subi %[[VAL_8]], %[[VAL_5]] : index 217! CHECK: %[[VAL_10:.*]] = arith.constant 41 : i64 218! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i64) -> index 219! CHECK: %[[VAL_12:.*]] = arith.constant 1 : i64 220! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index 221! CHECK: %[[VAL_14:.*]] = arith.constant 50 : i64 222! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index 223! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index 224! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_15]], %[[VAL_11]] : index 225! CHECK: %[[VAL_18:.*]] = arith.addi %[[VAL_17]], %[[VAL_13]] : index 226! CHECK: %[[VAL_19:.*]] = arith.divsi %[[VAL_18]], %[[VAL_13]] : index 227! CHECK: %[[VAL_20:.*]] = arith.cmpi sgt, %[[VAL_19]], %[[VAL_16]] : index 228! CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_19]], %[[VAL_16]] : index 229! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> 230! CHECK: %[[VAL_23:.*]] = fir.slice %[[VAL_6]], %[[VAL_7]], %[[VAL_7]], %[[VAL_11]], %[[VAL_15]], %[[VAL_13]] : (i64, index, index, index, index, index) -> !fir.slice<2> 231! CHECK: %[[VAL_24:.*]] = fir.array_load %[[VAL_0]](%[[VAL_22]]) {{\[}}%[[VAL_23]]] : (!fir.ref<!fir.array<10x50xf32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.array<10x50xf32> 232! CHECK: %[[VAL_25:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 233! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_1]](%[[VAL_25]]) : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> !fir.array<10xf32> 234! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index 235! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index 236! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_21]], %[[VAL_27]] : index 237! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_24]]) -> (!fir.array<10x50xf32>) { 238! CHECK: %[[VAL_33:.*]] = fir.array_fetch %[[VAL_26]], %[[VAL_31]] : (!fir.array<10xf32>, index) -> f32 239! CHECK: %[[VAL_34:.*]] = fir.array_update %[[VAL_32]], %[[VAL_33]], %[[VAL_9]], %[[VAL_31]] : (!fir.array<10x50xf32>, f32, index, index) -> !fir.array<10x50xf32> 240! CHECK: fir.result %[[VAL_34]] : !fir.array<10x50xf32> 241! CHECK: } 242! CHECK: fir.array_merge_store %[[VAL_24]], %[[VAL_35:.*]] to %[[VAL_0]]{{\[}}%[[VAL_23]]] : !fir.array<10x50xf32>, !fir.array<10x50xf32>, !fir.ref<!fir.array<10x50xf32>>, !fir.slice<2> 243! CHECK: return 244! CHECK: } 245 246subroutine test6b(a,b) 247 ! copy b to columns 41 to 50 of row 4 of a 248 real :: a(10,50) 249 real :: b(10) 250 a(4,41:50) = b 251end subroutine test6b 252 253! CHECK-LABEL: func @_QPtest7( 254! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<?xf32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}) { 255! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 256! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (i32) -> i64 257! CHECK: %[[VAL_5A:.*]] = fir.convert %[[VAL_4]] : (i64) -> index 258! CHECK: %[[C0:.*]] = arith.constant 0 : index 259! CHECK: %[[CMP:.*]] = arith.cmpi sgt, %[[VAL_5A]], %[[C0]] : index 260! CHECK: %[[VAL_5:.*]] = arith.select %[[CMP]], %[[VAL_5A]], %[[C0]] : index 261! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 262! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i32) -> i64 263! CHECK: %[[VAL_8A:.*]] = fir.convert %[[VAL_7]] : (i64) -> index 264! CHECK: %[[C0_2:.*]] = arith.constant 0 : index 265! CHECK: %[[CMP_2:.*]] = arith.cmpi sgt, %[[VAL_8A]], %[[C0_2]] : index 266! CHECK: %[[VAL_8:.*]] = arith.select %[[CMP_2]], %[[VAL_8A]], %[[C0_2]] : index 267! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 268! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_0]](%[[VAL_9]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> 269! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 270! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> 271! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1> 272! CHECK: %[[VAL_14:.*]] = fir.array_load %[[VAL_1]](%[[VAL_13]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> 273! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index 274! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index 275! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_5]], %[[VAL_15]] : index 276! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_10]]) -> (!fir.array<?xf32>) { 277! CHECK: %[[VAL_21:.*]] = fir.array_fetch %[[VAL_12]], %[[VAL_19]] : (!fir.array<?xf32>, index) -> f32 278! CHECK: %[[VAL_22:.*]] = fir.array_fetch %[[VAL_14]], %[[VAL_19]] : (!fir.array<?xf32>, index) -> f32 279! CHECK: %[[VAL_23:.*]] = arith.addf %[[VAL_21]], %[[VAL_22]] : f32 280! CHECK: %[[VAL_24:.*]] = fir.array_update %[[VAL_20]], %[[VAL_23]], %[[VAL_19]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32> 281! CHECK: fir.result %[[VAL_24]] : !fir.array<?xf32> 282! CHECK: } 283! CHECK: fir.array_merge_store %[[VAL_10]], %[[VAL_25:.*]] to %[[VAL_0]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>> 284! CHECK: return 285! CHECK: } 286 287! This is NOT a conflict. `a` appears on both the lhs and rhs here, but there 288! are no loop-carried dependences and no copy is needed. 289subroutine test7(a,b,n) 290 integer :: n 291 real, intent(inout) :: a(n) 292 real, intent(in) :: b(n) 293 a = a + b 294end subroutine test7 295 296! CHECK-LABEL: func @_QPtest8( 297! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<100xi32>>{{.*}}) { 298! CHECK: %[[VAL_2:.*]] = arith.constant 100 : index 299! CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1> 300! CHECK: %[[VAL_4:.*]] = fir.array_load %[[VAL_0]](%[[VAL_3]]) : (!fir.ref<!fir.array<100xi32>>, !fir.shape<1>) -> !fir.array<100xi32> 301! CHECK: %[[VAL_5:.*]] = arith.constant 1 : i64 302! CHECK: %[[VAL_6:.*]] = arith.constant 1 : i64 303! CHECK: %[[VAL_7:.*]] = arith.subi %[[VAL_5]], %[[VAL_6]] : i64 304! CHECK: %[[VAL_8:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_7]] : (!fir.ref<!fir.array<100xi32>>, i64) -> !fir.ref<i32> 305! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_8]] : !fir.ref<i32> 306! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index 307! CHECK: %[[VAL_11:.*]] = arith.constant 0 : index 308! CHECK: %[[VAL_12:.*]] = arith.subi %[[VAL_2]], %[[VAL_10]] : index 309! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_4]]) -> (!fir.array<100xi32>) { 310! CHECK: %[[VAL_16:.*]] = fir.array_update %[[VAL_15]], %[[VAL_9]], %[[VAL_14]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32> 311! CHECK: fir.result %[[VAL_16]] : !fir.array<100xi32> 312! CHECK: } 313! CHECK: fir.array_merge_store %[[VAL_4]], %[[VAL_17:.*]] to %[[VAL_0]] : !fir.array<100xi32>, !fir.array<100xi32>, !fir.ref<!fir.array<100xi32>> 314! CHECK: return 315! CHECK: } 316 317subroutine test8(a,b) 318 integer :: a(100), b(100) 319 a = b(1) 320end subroutine test8 321 322subroutine test10(a,b,c,d) 323 interface 324 ! Function takea an array and yields an array 325 function foo(a) result(res) 326 real :: a(:) ! FIXME: must be before res or semantics fails 327 ! as `size(a,1)` fails to resolve to the argument 328 real, dimension(size(a,1)) :: res 329 end function foo 330 end interface 331 interface 332 ! Function takes an array and yields a scalar 333 real function bar(a) 334 real :: a(:) 335 end function bar 336 end interface 337 real :: a(:), b(:), c(:), d(:) 338! a = b + foo(c + foo(d + bar(a))) 339end subroutine test10 340 341! CHECK-LABEL: func @_QPtest11( 342! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[VAL_3:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}) { 343! CHECK: %[[VAL_4:.*]] = arith.constant 100 : index 344! CHECK: %[[VAL_5:.*]] = arith.constant 100 : index 345! CHECK: %[[VAL_6:.*]] = arith.constant 100 : index 346! CHECK: %[[VAL_7:.*]] = arith.constant 100 : index 347! CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 348! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_0]](%[[VAL_8]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 349! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_5]] : (index) -> !fir.shape<1> 350! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_1]](%[[VAL_10]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 351! CHECK: %[[VAL_12:.*]] = arith.constant 100 : index 352! CHECK: %[[VAL_14:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> 353! CHECK: %[[VAL_15:.*]] = fir.array_load %[[VAL_2]](%[[VAL_14]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 354! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1> 355! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_3]](%[[VAL_16]]) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 356! CHECK: %[[VAL_18:.*]] = fir.allocmem !fir.array<100xf32> 357! CHECK: %[[VAL_19:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1> 358! CHECK: %[[VAL_20:.*]] = fir.array_load %[[VAL_18]](%[[VAL_19]]) : (!fir.heap<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 359! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index 360! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index 361! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_12]], %[[VAL_21]] : index 362! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array<100xf32>) { 363! CHECK: %[[VAL_27:.*]] = fir.array_fetch %[[VAL_15]], %[[VAL_25]] : (!fir.array<100xf32>, index) -> f32 364! CHECK: %[[VAL_28:.*]] = fir.array_fetch %[[VAL_17]], %[[VAL_25]] : (!fir.array<100xf32>, index) -> f32 365! CHECK: %[[VAL_29:.*]] = arith.addf %[[VAL_27]], %[[VAL_28]] : f32 366! CHECK: %[[VAL_30:.*]] = fir.array_update %[[VAL_26]], %[[VAL_29]], %[[VAL_25]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> 367! CHECK: fir.result %[[VAL_30]] : !fir.array<100xf32> 368! CHECK: } 369! CHECK: fir.array_merge_store %[[VAL_20]], %[[VAL_31:.*]] to %[[VAL_18]] : !fir.array<100xf32>, !fir.array<100xf32>, !fir.heap<!fir.array<100xf32>> 370! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_18]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>> 371! CHECK: %[[VAL_33:.*]] = fir.call @_QPbar(%[[VAL_32]]) : (!fir.ref<!fir.array<100xf32>>) -> f32 372! CHECK: %[[VAL_34:.*]] = arith.constant 1 : index 373! CHECK: %[[VAL_35:.*]] = arith.constant 0 : index 374! CHECK: %[[VAL_36:.*]] = arith.subi %[[VAL_4]], %[[VAL_34]] : index 375! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_36]] step %[[VAL_34]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_9]]) -> (!fir.array<100xf32>) { 376! CHECK: %[[VAL_40:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_38]] : (!fir.array<100xf32>, index) -> f32 377! CHECK: %[[VAL_41:.*]] = arith.addf %[[VAL_40]], %[[VAL_33]] : f32 378! CHECK: %[[VAL_42:.*]] = fir.array_update %[[VAL_39]], %[[VAL_41]], %[[VAL_38]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> 379! CHECK: fir.result %[[VAL_42]] : !fir.array<100xf32> 380! CHECK: } 381! CHECK: fir.array_merge_store %[[VAL_9]], %[[VAL_43:.*]] to %[[VAL_0]] : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>> 382! CHECK: fir.freemem %[[VAL_18]] 383! CHECK: return 384! CHECK: } 385 386subroutine test11(a,b,c,d) 387 real, external :: bar 388 real :: a(100), b(100), c(100), d(100) 389 a = b + bar(c + d) 390end subroutine test11 391 392! CHECK-LABEL: func @_QPtest12 393subroutine test12(a,b,c,d,n,m) 394 integer :: n, m 395 ! CHECK: %[[n:.*]] = fir.load %arg4 396 ! CHECK: %[[m:.*]] = fir.load %arg5 397 ! CHECK: %[[sha:.*]] = fir.shape % 398 ! CHECK: %[[A:.*]] = fir.array_load %arg0(%[[sha]]) 399 ! CHECK: %[[shb:.*]] = fir.shape % 400 ! CHECK: %[[B:.*]] = fir.array_load %arg1(%[[shb]]) 401 ! CHECK: %[[C:.*]] = fir.array_load %arg2(% 402 ! CHECK: %[[D:.*]] = fir.array_load %arg3(% 403 ! CHECK: %[[tmp:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}} {{{.*}}uniq_name = ".array.expr"} 404 ! CHECK: %[[T:.*]] = fir.array_load %[[tmp]](% 405 real, external :: bar 406 real :: a(n), b(n), c(m), d(m) 407 ! CHECK: %[[LOOP:.*]] = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %[[T]]) 408 ! CHECK-DAG: fir.array_fetch %[[C]] 409 ! CHECK-DAG: fir.array_fetch %[[D]] 410 ! CHECK: fir.array_merge_store %[[T]], %[[LOOP]] 411 ! CHECK: %[[CALL:.*]] = fir.call @_QPbar 412 ! CHECK: %[[LOOP2:.*]] = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %[[A]]) 413 ! CHECK: fir.array_fetch %[[B]] 414 ! CHECK: fir.array_merge_store %[[A]], %[[LOOP2]] to %arg0 415 a = b + bar(c + d) 416 ! CHECK: fir.freemem %[[tmp]] : !fir.heap<!fir.array<?xf32>> 417end subroutine test12 418 419! CHECK-LABEL: func @_QPtest13 420subroutine test13(a,b,c,d,n,m,i) 421 real :: a(n), b(m) 422 complex :: c(n), d(m) 423 ! CHECK: %[[A_shape:.*]] = fir.shape % 424 ! CHECK: %[[A:.*]] = fir.array_load %arg0(%[[A_shape]]) 425 ! CHECK: %[[B_shape:.*]] = fir.shape % 426 ! CHECK: %[[B_slice:.*]] = fir.slice % 427 ! CHECK: %[[B:.*]] = fir.array_load %arg1(%[[B_shape]]) [%[[B_slice]]] 428 ! CHECK: %[[C_shape:.*]] = fir.shape % 429 ! CHECK: %[[C_slice:.*]] = fir.slice %{{.*}}, %{{.*}}, %{{.*}} path % 430 ! CHECK: %[[C:.*]] = fir.array_load %arg2(%[[C_shape]]) [%[[C_slice]]] 431 ! CHECK: %[[D_shape:.*]] = fir.shape % 432 ! CHECK: %[[D_slice:.*]] = fir.slice %{{.*}}, %{{.*}}, %{{.*}} path % 433 ! CHECK: %[[D:.*]] = fir.array_load %arg3(%[[D_shape]]) [%[[D_slice]]] 434 ! CHECK: = arith.constant -6.2598534E+18 : f32 435 ! CHECK: %[[A_result:.*]] = fir.do_loop %{{.*}} = %{{.*}} iter_args(%[[A_in:.*]] = %[[A]]) -> 436 ! CHECK: fir.array_fetch %[[B]], 437 ! CHECK: fir.array_fetch %[[C]], 438 ! CHECK: fir.array_fetch %[[D]], 439 ! CHECK: fir.array_update %[[A_in]], 440 a = b(i:i+2*n-2:2) + c%im - d(i:i+2*n-2:2)%re + x'deadbeef' 441 ! CHECK: fir.array_merge_store %[[A]], %[[A_result]] to %arg0 442end subroutine test13 443 444! Test elemental call to function f 445! CHECK-LABEL: func @_QPtest14( 446! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}) 447subroutine test14(a,b) 448 ! CHECK: %[[barr:.*]] = fir.array_load %[[b]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 449 interface 450 real elemental function f1(i) 451 real, intent(in) :: i 452 end function f1 453 end interface 454 real :: a(100), b(100) 455 ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { 456 ! CHECK: %[[ishift:.*]] = arith.addi %[[i]], %c1{{.*}} : index 457 ! CHECK: %[[tmp:.*]] = fir.array_coor %[[a]](%{{.*}}) %[[ishift]] : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32> 458 ! CHECK: %[[fres:.*]] = fir.call @_QPf1(%[[tmp]]) : (!fir.ref<f32>) -> f32 459 ! CHECK: %[[res:.*]] = fir.array_update %[[bth]], %[[fres]], %[[i]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> 460 ! CHECK: fir.result %[[res]] : !fir.array<100xf32> 461 ! CHECK: fir.array_merge_store %[[barr]], %[[loop]] to %[[b]] 462 b = f1(a) 463end subroutine test14 464 465! Test elemental intrinsic function (abs) 466! CHECK-LABEL: func @_QPtest15( 467! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}) 468subroutine test15(a,b) 469 ! CHECK-DAG: %[[barr:.*]] = fir.array_load %[[b]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 470 ! CHECK-DAG: %[[aarr:.*]] = fir.array_load %[[a]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 471 real :: a(100), b(100) 472 ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { 473 ! CHECK: %[[val:.*]] = fir.array_fetch %[[aarr]], %[[i]] : (!fir.array<100xf32>, index) -> f32 474 ! CHECK: %[[fres:.*]] = math.abs %[[val]] : f32 475 ! CHECK: %[[res:.*]] = fir.array_update %[[bth]], %[[fres]], %[[i]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> 476 ! CHECK: fir.result %[[res]] : !fir.array<100xf32> 477 ! CHECK: fir.array_merge_store %[[barr]], %[[loop]] to %[[b]] 478 b = abs(a) 479end subroutine test15 480 481! Test elemental call to function f2 with VALUE attribute 482! CHECK-LABEL: func @_QPtest16( 483! CHECK-SAME: %[[a:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[b:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}) 484subroutine test16(a,b) 485 ! CHECK: %[[tmp:.*]] = fir.alloca f32 {adapt.valuebyref 486 ! CHECK-DAG: %[[aarr:.*]] = fir.array_load %[[a]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 487 ! CHECK-DAG: %[[barr:.*]] = fir.array_load %[[b]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 488 interface 489 real elemental function f2(i) 490 real, VALUE :: i 491 end function f2 492 end interface 493 real :: a(100), b(100) 494 ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { 495 ! CHECK: %[[val:.*]] = fir.array_fetch %[[aarr]], %[[i]] : (!fir.array<100xf32>, index) -> f32 496 ! CHECK: fir.store %[[val]] to %[[tmp]] 497 ! CHECK: %[[fres:.*]] = fir.call @_QPf2(%[[tmp]]) : (!fir.ref<f32>) -> f32 498 ! CHECK: %[[res:.*]] = fir.array_update %[[bth]], %[[fres]], %[[i]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> 499 ! CHECK: fir.result %[[res]] : !fir.array<100xf32> 500 ! CHECK: fir.array_merge_store %[[barr]], %[[loop]] to %[[b]] 501 b = f2(a) 502end subroutine test16 503 504! Test elemental impure call to function f3. 505! 506! CHECK-LABEL: func @_QPtest17( 507! CHECK-SAME: %[[a:[^:]+]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[b:[^:]+]]: !fir.ref<!fir.array<100xf32>>{{.*}}, %[[c:.*]]: !fir.ref<!fir.array<100xf32>>{{.*}}) 508subroutine test17(a,b,c) 509 ! CHECK-DAG: %[[aarr:.*]] = fir.array_load %[[a]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32> 510 ! CHECK-DAG: %[[barr:.*]] = fir.array_load %[[b]](%{{.*}}) : (!fir.ref<!fir.array<100xf32>>, !fir.shapeshift<1>) -> !fir.array<100xf32> 511 interface 512 real elemental impure function f3(i,j,k) 513 real, intent(inout) :: i, j, k 514 end function f3 515 end interface 516 real :: a(100), b(2:101), c(3:102) 517 ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { 518 ! CHECK-DAG: %[[val:.*]] = fir.array_fetch %[[aarr]], %[[i]] : (!fir.array<100xf32>, index) -> f32 519 ! CHECK-DAG: %[[ic:.*]] = arith.addi %[[i]], %c3{{.*}} : index 520 ! CHECK-DAG: %[[ccoor:.*]] = fir.array_coor %[[c]](%{{.*}}) %[[ic]] : (!fir.ref<!fir.array<100xf32>>, !fir.shapeshift<1>, index) -> !fir.ref<f32> 521 ! CHECK-DAG: %[[ib:.*]] = arith.addi %[[i]], %c2{{.*}} : index 522 ! CHECK-DAG: %[[bcoor:.*]] = fir.array_coor %[[b]](%{{.*}}) %[[ib]] : (!fir.ref<!fir.array<100xf32>>, !fir.shapeshift<1>, index) -> !fir.ref<f32> 523 ! CHECK-DAG: %[[ia:.*]] = arith.addi %[[i]], %c1{{.*}} : index 524 ! CHECK-DAG: %[[acoor:.*]] = fir.array_coor %[[a]](%{{.*}}) %[[ia]] : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32> 525 ! CHECK: %[[fres:.*]] = fir.call @_QPf3(%[[ccoor]], %[[bcoor]], %[[acoor]]) : (!fir.ref<f32>, !fir.ref<f32>, !fir.ref<f32>) -> f32 526 ! CHECK: %[[fadd:.*]] = arith.addf %[[val]], %[[fres]] : f32 527 ! CHECK: %[[res:.*]] = fir.array_update %[[bth]], %[[fadd]], %[[i]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> 528 529 ! See 10.1.4.p2 note 1. The expression below is illegal if `f3` defines the 530 ! argument `a` for this statement. Since, this cannot be proven statically by 531 ! the compiler, the constraint is left to the user. The compiler may give a 532 ! warning that `k` is neither VALUE nor INTENT(IN) and the actual argument, 533 ! `a`, appears elsewhere in the same statement. 534 b = a + f3(c, b, a) 535 536 ! CHECK: fir.result %[[res]] : !fir.array<100xf32> 537 ! CHECK: fir.array_merge_store %[[barr]], %[[loop]] to %[[b]] 538end subroutine test17 539 540! CHECK-LABEL: func @_QPtest18() { 541! CHECK: %[[VAL_0:.*]] = arith.constant 10 : index 542! CHECK: %[[VAL_1:.*]] = arith.constant 10 : index 543! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<10x10xi32> {bindc_name = "array", fir.target, uniq_name = "_QFtest18Earray"} 544! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest18Ei"} 545! CHECK: %[[VAL_4:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>> {bindc_name = "row_i", uniq_name = "_QFtest18Erow_i"} 546! CHECK: %[[VAL_5:.*]] = fir.zero_bits !fir.ptr<!fir.array<?xi32>> 547! CHECK: %[[VAL_6:.*]] = arith.constant 0 : index 548! CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> 549! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_5]](%[[VAL_7]]) : (!fir.ptr<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>> 550! CHECK: fir.store %[[VAL_8]] to %[[VAL_4]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> 551! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index 552! CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> 553! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> i64 554! CHECK: %[[VAL_12:.*]] = fir.undefined index 555! CHECK: %[[VAL_13:.*]] = arith.constant 1 : i64 556! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index 557! CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_9]], %[[VAL_1]] : index 558! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_15]], %[[VAL_9]] : index 559! CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_0]], %[[VAL_1]] : (index, index) -> !fir.shape<2> 560! CHECK: %[[VAL_18:.*]] = fir.slice %[[VAL_11]], %[[VAL_12]], %[[VAL_12]], %[[VAL_9]], %[[VAL_16]], %[[VAL_14]] : (i64, index, index, index, index, index) -> !fir.slice<2> 561! CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_2]](%[[VAL_17]]) {{\[}}%[[VAL_18]]] : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xi32>> 562! CHECK: %[[VAL_20:.*]] = fir.rebox %[[VAL_19]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>> 563! CHECK: fir.store %[[VAL_20]] to %[[VAL_4]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> 564! CHECK: return 565! CHECK: } 566 567subroutine test18 568 integer, target :: array(10,10) 569 integer, pointer :: row_i(:) 570 row_i => array(i, :) 571end subroutine test18 572 573! CHECK-LABEL: func @_QPtest_column_and_row_order( 574! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<2x3xf32>>{{.*}}) { 575! CHECK: %[[VAL_1:.*]] = arith.constant 2 : index 576! CHECK: %[[VAL_2:.*]] = arith.constant 3 : index 577! CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> 578! CHECK: %[[VAL_4:.*]] = fir.array_load %[[VAL_0]](%[[VAL_3]]) : (!fir.ref<!fir.array<2x3xf32>>, !fir.shape<2>) -> !fir.array<2x3xf32> 579! CHECK: %[[VAL_5:.*]] = arith.constant 42 : i32 580! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i32) -> f32 581! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index 582! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index 583! CHECK: %[[VAL_9:.*]] = arith.subi %[[VAL_1]], %[[VAL_7]] : index 584! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_2]], %[[VAL_7]] : index 585! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_7]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_4]]) -> (!fir.array<2x3xf32>) { 586! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_7]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_13]]) -> (!fir.array<2x3xf32>) { 587! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_16]], %[[VAL_6]], %[[VAL_15]], %[[VAL_12]] : (!fir.array<2x3xf32>, f32, index, index) -> !fir.array<2x3xf32> 588! CHECK: fir.result %[[VAL_17]] : !fir.array<2x3xf32> 589! CHECK: } 590! CHECK: fir.result %[[VAL_18:.*]] : !fir.array<2x3xf32> 591! CHECK: } 592! CHECK: fir.array_merge_store %[[VAL_4]], %[[VAL_19:.*]] to %[[VAL_0]] : !fir.array<2x3xf32>, !fir.array<2x3xf32>, !fir.ref<!fir.array<2x3xf32>> 593! CHECK: return 594! CHECK: } 595 596subroutine test_column_and_row_order(x) 597 real :: x(2,3) 598 x = 42 599end subroutine 600 601! CHECK-LABEL: func @_QPtest_assigning_to_assumed_shape_slices( 602! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) { 603! CHECK: %[[VAL_1:.*]] = arith.constant 1 : index 604! CHECK: %[[VAL_2:.*]] = arith.constant 2 : i64 605! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (i64) -> index 606! CHECK: %[[VAL_4:.*]] = arith.constant 0 : index 607! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_4]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) 608! CHECK: %[[VAL_6:.*]] = arith.addi %[[VAL_1]], %[[VAL_5]]#1 : index 609! CHECK: %[[VAL_7:.*]] = arith.subi %[[VAL_6]], %[[VAL_1]] : index 610! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index 611! CHECK: %[[VAL_9:.*]] = arith.subi %[[VAL_7]], %[[VAL_1]] : index 612! CHECK: %[[VAL_10:.*]] = arith.addi %[[VAL_9]], %[[VAL_3]] : index 613! CHECK: %[[VAL_11:.*]] = arith.divsi %[[VAL_10]], %[[VAL_3]] : index 614! CHECK: %[[VAL_12:.*]] = arith.cmpi sgt, %[[VAL_11]], %[[VAL_8]] : index 615! CHECK: %[[VAL_13:.*]] = arith.select %[[VAL_12]], %[[VAL_11]], %[[VAL_8]] : index 616! CHECK: %[[VAL_14:.*]] = fir.slice %[[VAL_1]], %[[VAL_7]], %[[VAL_3]] : (index, index, index) -> !fir.slice<1> 617! CHECK: %[[VAL_15:.*]] = fir.array_load %[[VAL_0]] {{\[}}%[[VAL_14]]] : (!fir.box<!fir.array<?xi32>>, !fir.slice<1>) -> !fir.array<?xi32> 618! CHECK: %[[VAL_16:.*]] = arith.constant 42 : i32 619! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index 620! CHECK: %[[VAL_18:.*]] = arith.constant 0 : index 621! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_13]], %[[VAL_17]] : index 622! CHECK: %[[VAL_20:.*]] = fir.do_loop %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_17]] unordered iter_args(%[[VAL_22:.*]] = %[[VAL_15]]) -> (!fir.array<?xi32>) { 623! CHECK: %[[VAL_23:.*]] = fir.array_update %[[VAL_22]], %[[VAL_16]], %[[VAL_21]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32> 624! CHECK: fir.result %[[VAL_23]] : !fir.array<?xi32> 625! CHECK: } 626! CHECK: fir.array_merge_store %[[VAL_15]], %[[VAL_24:.*]] to %[[VAL_0]]{{\[}}%[[VAL_14]]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>, !fir.slice<1> 627! CHECK: return 628! CHECK: } 629 630subroutine test_assigning_to_assumed_shape_slices(x) 631 integer :: x(:) 632 x(::2) = 42 633end subroutine 634 635! CHECK-LABEL: func @_QPtest19a( 636! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 637! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 638! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,10>>> 639! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index 640! CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 641! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,10>>> 642! CHECK: %[[VAL_7:.*]] = arith.constant 10 : index 643! CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 644! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_3]](%[[VAL_8]]) : (!fir.ref<!fir.array<10x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<10x!fir.char<1,10>> 645! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1> 646! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_6]](%[[VAL_10]]) : (!fir.ref<!fir.array<10x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.array<10x!fir.char<1,10>> 647! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index 648! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index 649! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_4]], %[[VAL_12]] : index 650! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_9]]) -> (!fir.array<10x!fir.char<1,10>>) { 651! CHECK: %[[VAL_18:.*]] = fir.array_access %[[VAL_11]], %[[VAL_16]] : (!fir.array<10x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>> 652! CHECK: %[[VAL_19:.*]] = fir.array_access %[[VAL_17]], %[[VAL_16]] : (!fir.array<10x!fir.char<1,10>>, index) -> !fir.ref<!fir.char<1,10>> 653! CHECK: %[[VAL_20:.*]] = arith.constant 10 : index 654! CHECK: %[[VAL_21:.*]] = arith.constant 1 : i64 655! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_20]] : (index) -> i64 656! CHECK: %[[VAL_23:.*]] = arith.muli %[[VAL_21]], %[[VAL_22]] : i64 657! CHECK: %[[VAL_24:.*]] = arith.constant false 658! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_19]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8> 659! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8> 660! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_25]], %[[VAL_26]], %[[VAL_23]], %[[VAL_24]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 661! CHECK: %[[VAL_27:.*]] = fir.array_amend %[[VAL_17]], %[[VAL_19]] : (!fir.array<10x!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) -> !fir.array<10x!fir.char<1,10>> 662! CHECK: fir.result %[[VAL_27]] : !fir.array<10x!fir.char<1,10>> 663! CHECK: } 664! CHECK: fir.array_merge_store %[[VAL_9]], %[[VAL_28:.*]] to %[[VAL_3]] : !fir.array<10x!fir.char<1,10>>, !fir.array<10x!fir.char<1,10>>, !fir.ref<!fir.array<10x!fir.char<1,10>>> 665! CHECK: return 666! CHECK: } 667 668subroutine test19a(a,b) 669 character(LEN=10) a(10) 670 character(LEN=10) b(10) 671 a = b 672end subroutine test19a 673 674! CHECK-LABEL: func @_QPtest19b( 675! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<2>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<2>{{.*}}) { 676! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<2>) -> (!fir.ref<!fir.char<2,?>>, index) 677! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<2,?>>) -> !fir.ref<!fir.array<20x!fir.char<2,8>>> 678! CHECK: %[[VAL_4:.*]] = arith.constant 20 : index 679! CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<2>) -> (!fir.ref<!fir.char<2,?>>, index) 680! CHECK: %[[VAL_6:.*]] = arith.constant 10 : index 681! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_5]]#0 : (!fir.ref<!fir.char<2,?>>) -> !fir.ref<!fir.array<20x!fir.char<2,10>>> 682! CHECK: %[[VAL_8:.*]] = arith.constant 20 : index 683! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 684! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_3]](%[[VAL_9]]) : (!fir.ref<!fir.array<20x!fir.char<2,8>>>, !fir.shape<1>) -> !fir.array<20x!fir.char<2,8>> 685! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1> 686! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_7]](%[[VAL_11]]) : (!fir.ref<!fir.array<20x!fir.char<2,10>>>, !fir.shape<1>) -> !fir.array<20x!fir.char<2,10>> 687! CHECK: %[[VAL_13:.*]] = arith.constant 1 : index 688! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index 689! CHECK: %[[VAL_15:.*]] = arith.subi %[[VAL_4]], %[[VAL_13]] : index 690! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_13]] unordered iter_args(%[[VAL_18:.*]] = %[[VAL_10]]) -> (!fir.array<20x!fir.char<2,8>>) { 691! CHECK: %[[VAL_19:.*]] = fir.array_access %[[VAL_12]], %[[VAL_17]] : (!fir.array<20x!fir.char<2,10>>, index) -> !fir.ref<!fir.char<2,10>> 692! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_18]], %[[VAL_17]] : (!fir.array<20x!fir.char<2,8>>, index) -> !fir.ref<!fir.char<2,8>> 693! CHECK: %[[VAL_21:.*]] = arith.constant 8 : index 694! CHECK: %[[VAL_22:.*]] = arith.cmpi slt, %[[VAL_21]], %[[VAL_6]] : index 695! CHECK: %[[VAL_23:.*]] = arith.select %[[VAL_22]], %[[VAL_21]], %[[VAL_6]] : index 696! CHECK: %[[VAL_24:.*]] = arith.constant 2 : i64 697! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_23]] : (index) -> i64 698! CHECK: %[[VAL_26:.*]] = arith.muli %[[VAL_24]], %[[VAL_25]] : i64 699! CHECK: %[[VAL_27:.*]] = arith.constant false 700! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_20]] : (!fir.ref<!fir.char<2,8>>) -> !fir.ref<i8> 701! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_19]] : (!fir.ref<!fir.char<2,10>>) -> !fir.ref<i8> 702! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_28]], %[[VAL_29]], %[[VAL_26]], %[[VAL_27]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 703! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index 704! CHECK: %[[VAL_31:.*]] = arith.subi %[[VAL_21]], %[[VAL_30]] : index 705! CHECK: %[[VAL_32:.*]] = arith.constant 32 : i16 706! CHECK: %[[VAL_33:.*]] = fir.undefined !fir.char<2> 707! CHECK: %[[VAL_34:.*]] = fir.insert_value %[[VAL_33]], %[[VAL_32]], [0 : index] : (!fir.char<2>, i16) -> !fir.char<2> 708! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index 709! CHECK: fir.do_loop %[[VAL_36:.*]] = %[[VAL_23]] to %[[VAL_31]] step %[[VAL_35]] { 710! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_20]] : (!fir.ref<!fir.char<2,8>>) -> !fir.ref<!fir.array<8x!fir.char<2>>> 711! CHECK: %[[VAL_38:.*]] = fir.coordinate_of %[[VAL_37]], %[[VAL_36]] : (!fir.ref<!fir.array<8x!fir.char<2>>>, index) -> !fir.ref<!fir.char<2>> 712! CHECK: fir.store %[[VAL_34]] to %[[VAL_38]] : !fir.ref<!fir.char<2>> 713! CHECK: } 714! CHECK: %[[VAL_39:.*]] = fir.array_amend %[[VAL_18]], %[[VAL_20]] : (!fir.array<20x!fir.char<2,8>>, !fir.ref<!fir.char<2,8>>) -> !fir.array<20x!fir.char<2,8>> 715! CHECK: fir.result %[[VAL_39]] : !fir.array<20x!fir.char<2,8>> 716! CHECK: } 717! CHECK: fir.array_merge_store %[[VAL_10]], %[[VAL_40:.*]] to %[[VAL_3]] : !fir.array<20x!fir.char<2,8>>, !fir.array<20x!fir.char<2,8>>, !fir.ref<!fir.array<20x!fir.char<2,8>>> 718! CHECK: return 719! CHECK: } 720 721subroutine test19b(a,b) 722 character(KIND=2, LEN=8) a(20) 723 character(KIND=2, LEN=10) b(20) 724 a = b 725end subroutine test19b 726 727! CHECK-LABEL: func @_QPtest19c( 728! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<4>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<4>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}) { 729! CHECK: %[[VAL_3:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<4>) -> (!fir.ref<!fir.char<4,?>>, index) 730! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index 731! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_3]]#0 : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<!fir.array<30x!fir.char<4,10>>> 732! CHECK: %[[VAL_6:.*]] = arith.constant 30 : index 733! CHECK: %[[VAL_7:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<4>) -> (!fir.ref<!fir.char<4,?>>, index) 734! CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 735! CHECK: %[[VAL_9:.*]] = arith.constant 0 : i32 736! CHECK: %[[VAL_10:.*]] = arith.cmpi sgt, %[[VAL_8]], %[[VAL_9]] : i32 737! CHECK: %[[VAL_11:.*]] = arith.select %[[VAL_10]], %[[VAL_8]], %[[VAL_9]] : i32 738! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_7]]#0 : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<!fir.array<30x!fir.char<4,?>>> 739! CHECK: %[[VAL_13:.*]] = arith.constant 30 : index 740! CHECK: %[[VAL_14:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1> 741! CHECK: %[[VAL_15:.*]] = fir.array_load %[[VAL_12]](%[[VAL_14]]) typeparams %[[VAL_11]] : (!fir.ref<!fir.array<30x!fir.char<4,?>>>, !fir.shape<1>, i32) -> !fir.array<30x!fir.char<4,?>> 742! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> 743! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_5]](%[[VAL_16]]) : (!fir.ref<!fir.array<30x!fir.char<4,10>>>, !fir.shape<1>) -> !fir.array<30x!fir.char<4,10>> 744! CHECK: %[[VAL_18:.*]] = arith.constant 1 : index 745! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index 746! CHECK: %[[VAL_20:.*]] = arith.subi %[[VAL_13]], %[[VAL_18]] : index 747! CHECK: %[[VAL_21:.*]] = fir.do_loop %[[VAL_22:.*]] = %[[VAL_19]] to %[[VAL_20]] step %[[VAL_18]] unordered iter_args(%[[VAL_23:.*]] = %[[VAL_15]]) -> (!fir.array<30x!fir.char<4,?>>) { 748! CHECK: %[[VAL_24:.*]] = fir.array_access %[[VAL_17]], %[[VAL_22]] : (!fir.array<30x!fir.char<4,10>>, index) -> !fir.ref<!fir.char<4,10>> 749! CHECK: %[[VAL_25:.*]] = fir.array_access %[[VAL_23]], %[[VAL_22]] typeparams %[[VAL_11]] : (!fir.array<30x!fir.char<4,?>>, index, i32) -> !fir.ref<!fir.char<4,?>> 750! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_11]] : (i32) -> index 751! CHECK: %[[VAL_27:.*]] = arith.cmpi slt, %[[VAL_26]], %[[VAL_4]] : index 752! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_26]], %[[VAL_4]] : index 753! CHECK: %[[VAL_29:.*]] = arith.constant 4 : i64 754! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_28]] : (index) -> i64 755! CHECK: %[[VAL_31:.*]] = arith.muli %[[VAL_29]], %[[VAL_30]] : i64 756! CHECK: %[[VAL_32:.*]] = arith.constant false 757! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_25]] : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<i8> 758! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_24]] : (!fir.ref<!fir.char<4,10>>) -> !fir.ref<i8> 759! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_33]], %[[VAL_34]], %[[VAL_31]], %[[VAL_32]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 760! CHECK: %[[VAL_35:.*]] = arith.constant 1 : i32 761! CHECK: %[[VAL_36:.*]] = arith.subi %[[VAL_11]], %[[VAL_35]] : i32 762! CHECK: %[[VAL_37:.*]] = arith.constant 32 : i32 763! CHECK: %[[VAL_38:.*]] = fir.undefined !fir.char<4> 764! CHECK: %[[VAL_39:.*]] = fir.insert_value %[[VAL_38]], %[[VAL_37]], [0 : index] : (!fir.char<4>, i32) -> !fir.char<4> 765! CHECK: %[[VAL_40:.*]] = arith.constant 1 : index 766! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_36]] : (i32) -> index 767! CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_28]] to %[[VAL_41]] step %[[VAL_40]] { 768! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_25]] : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<!fir.array<?x!fir.char<4>>> 769! CHECK: %[[VAL_44:.*]] = fir.coordinate_of %[[VAL_43]], %[[VAL_42]] : (!fir.ref<!fir.array<?x!fir.char<4>>>, index) -> !fir.ref<!fir.char<4>> 770! CHECK: fir.store %[[VAL_39]] to %[[VAL_44]] : !fir.ref<!fir.char<4>> 771! CHECK: } 772! CHECK: %[[VAL_45:.*]] = fir.array_amend %[[VAL_23]], %[[VAL_25]] : (!fir.array<30x!fir.char<4,?>>, !fir.ref<!fir.char<4,?>>) -> !fir.array<30x!fir.char<4,?>> 773! CHECK: fir.result %[[VAL_45]] : !fir.array<30x!fir.char<4,?>> 774! CHECK: } 775! CHECK: fir.array_merge_store %[[VAL_15]], %[[VAL_46:.*]] to %[[VAL_12]] typeparams %[[VAL_11]] : !fir.array<30x!fir.char<4,?>>, !fir.array<30x!fir.char<4,?>>, !fir.ref<!fir.array<30x!fir.char<4,?>>>, i32 776! CHECK: return 777! CHECK: } 778 779subroutine test19c(a,b,i) 780 character(KIND=4, LEN=i) a(30) 781 character(KIND=4, LEN=10) b(30) 782 a = b 783end subroutine test19c 784 785! CHECK-LABEL: func @_QPtest19d( 786! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}, %[[VAL_3:.*]]: !fir.ref<i32>{{.*}}) { 787! CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 788! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 789! CHECK: %[[VAL_6:.*]] = arith.constant 0 : i32 790! CHECK: %[[VAL_7:.*]] = arith.cmpi sgt, %[[VAL_5]], %[[VAL_6]] : i32 791! CHECK: %[[VAL_8:.*]] = arith.select %[[VAL_7]], %[[VAL_5]], %[[VAL_6]] : i32 792! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<40x!fir.char<1,?>>> 793! CHECK: %[[VAL_10:.*]] = arith.constant 40 : index 794! CHECK: %[[VAL_11:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 795! CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> 796! CHECK: %[[VAL_13:.*]] = arith.constant 0 : i32 797! CHECK: %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_12]], %[[VAL_13]] : i32 798! CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[VAL_12]], %[[VAL_13]] : i32 799! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_11]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<40x!fir.char<1,?>>> 800! CHECK: %[[VAL_17:.*]] = arith.constant 40 : index 801! CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1> 802! CHECK: %[[VAL_19:.*]] = fir.array_load %[[VAL_9]](%[[VAL_18]]) typeparams %[[VAL_8]] : (!fir.ref<!fir.array<40x!fir.char<1,?>>>, !fir.shape<1>, i32) -> !fir.array<40x!fir.char<1,?>> 803! CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_17]] : (index) -> !fir.shape<1> 804! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_16]](%[[VAL_20]]) typeparams %[[VAL_15]] : (!fir.ref<!fir.array<40x!fir.char<1,?>>>, !fir.shape<1>, i32) -> !fir.array<40x!fir.char<1,?>> 805! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index 806! CHECK: %[[VAL_23:.*]] = arith.constant 0 : index 807! CHECK: %[[VAL_24:.*]] = arith.subi %[[VAL_10]], %[[VAL_22]] : index 808! CHECK: %[[VAL_25:.*]] = fir.do_loop %[[VAL_26:.*]] = %[[VAL_23]] to %[[VAL_24]] step %[[VAL_22]] unordered iter_args(%[[VAL_27:.*]] = %[[VAL_19]]) -> (!fir.array<40x!fir.char<1,?>>) { 809! CHECK: %[[VAL_28:.*]] = fir.array_access %[[VAL_21]], %[[VAL_26]] typeparams %[[VAL_15]] : (!fir.array<40x!fir.char<1,?>>, index, i32) -> !fir.ref<!fir.char<1,?>> 810! CHECK: %[[VAL_29:.*]] = fir.array_access %[[VAL_27]], %[[VAL_26]] typeparams %[[VAL_8]] : (!fir.array<40x!fir.char<1,?>>, index, i32) -> !fir.ref<!fir.char<1,?>> 811! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_8]] : (i32) -> index 812! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_15]] : (i32) -> index 813! CHECK: %[[VAL_32:.*]] = arith.cmpi slt, %[[VAL_30]], %[[VAL_31]] : index 814! CHECK: %[[VAL_33:.*]] = arith.select %[[VAL_32]], %[[VAL_30]], %[[VAL_31]] : index 815! CHECK: %[[VAL_34:.*]] = arith.constant 1 : i64 816! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_33]] : (index) -> i64 817! CHECK: %[[VAL_36:.*]] = arith.muli %[[VAL_34]], %[[VAL_35]] : i64 818! CHECK: %[[VAL_37:.*]] = arith.constant false 819! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_29]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 820! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 821! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_38]], %[[VAL_39]], %[[VAL_36]], %[[VAL_37]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 822! CHECK: %[[VAL_40:.*]] = arith.constant 1 : i32 823! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_8]], %[[VAL_40]] : i32 824! CHECK: %[[VAL_42:.*]] = arith.constant 32 : i8 825! CHECK: %[[VAL_43:.*]] = fir.undefined !fir.char<1> 826! CHECK: %[[VAL_44:.*]] = fir.insert_value %[[VAL_43]], %[[VAL_42]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> 827! CHECK: %[[VAL_45:.*]] = arith.constant 1 : index 828! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_41]] : (i32) -> index 829! CHECK: fir.do_loop %[[VAL_47:.*]] = %[[VAL_33]] to %[[VAL_46]] step %[[VAL_45]] { 830! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_29]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>> 831! CHECK: %[[VAL_49:.*]] = fir.coordinate_of %[[VAL_48]], %[[VAL_47]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>> 832! CHECK: fir.store %[[VAL_44]] to %[[VAL_49]] : !fir.ref<!fir.char<1>> 833! CHECK: } 834! CHECK: %[[VAL_50:.*]] = fir.array_amend %[[VAL_27]], %[[VAL_29]] : (!fir.array<40x!fir.char<1,?>>, !fir.ref<!fir.char<1,?>>) -> !fir.array<40x!fir.char<1,?>> 835! CHECK: fir.result %[[VAL_50]] : !fir.array<40x!fir.char<1,?>> 836! CHECK: } 837! CHECK: fir.array_merge_store %[[VAL_19]], %[[VAL_51:.*]] to %[[VAL_9]] typeparams %[[VAL_8]] : !fir.array<40x!fir.char<1,?>>, !fir.array<40x!fir.char<1,?>>, !fir.ref<!fir.array<40x!fir.char<1,?>>>, i32 838! CHECK: return 839! CHECK: } 840 841subroutine test19d(a,b,i,j) 842 character(i) a(40) 843 character(j) b(40) 844 a = b 845end subroutine test19d 846 847! CHECK-LABEL: func @_QPtest19e( 848! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 849! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 850! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<50x!fir.char<1,?>>> 851! CHECK: %[[VAL_4:.*]] = arith.constant 50 : index 852! CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 853! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<50x!fir.char<1,?>>> 854! CHECK: %[[VAL_7:.*]] = arith.constant 50 : index 855! CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 856! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_3]](%[[VAL_8]]) typeparams %[[VAL_2]]#1 : (!fir.ref<!fir.array<50x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.array<50x!fir.char<1,?>> 857! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1> 858! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_6]](%[[VAL_10]]) typeparams %[[VAL_5]]#1 : (!fir.ref<!fir.array<50x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.array<50x!fir.char<1,?>> 859! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index 860! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index 861! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_4]], %[[VAL_12]] : index 862! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_9]]) -> (!fir.array<50x!fir.char<1,?>>) { 863! CHECK: %[[VAL_18:.*]] = fir.array_access %[[VAL_11]], %[[VAL_16]] typeparams %[[VAL_5]]#1 : (!fir.array<50x!fir.char<1,?>>, index, index) -> !fir.ref<!fir.char<1,?>> 864! CHECK: %[[VAL_19:.*]] = fir.array_access %[[VAL_17]], %[[VAL_16]] typeparams %[[VAL_2]]#1 : (!fir.array<50x!fir.char<1,?>>, index, index) -> !fir.ref<!fir.char<1,?>> 865! CHECK: %[[VAL_20:.*]] = arith.cmpi slt, %[[VAL_2]]#1, %[[VAL_5]]#1 : index 866! CHECK: %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_2]]#1, %[[VAL_5]]#1 : index 867! CHECK: %[[VAL_22:.*]] = arith.constant 1 : i64 868! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_21]] : (index) -> i64 869! CHECK: %[[VAL_24:.*]] = arith.muli %[[VAL_22]], %[[VAL_23]] : i64 870! CHECK: %[[VAL_25:.*]] = arith.constant false 871! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_19]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 872! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 873! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_26]], %[[VAL_27]], %[[VAL_24]], %[[VAL_25]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 874! CHECK: %[[VAL_28:.*]] = arith.constant 1 : index 875! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_2]]#1, %[[VAL_28]] : index 876! CHECK: %[[VAL_30:.*]] = arith.constant 32 : i8 877! CHECK: %[[VAL_31:.*]] = fir.undefined !fir.char<1> 878! CHECK: %[[VAL_32:.*]] = fir.insert_value %[[VAL_31]], %[[VAL_30]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> 879! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index 880! CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_21]] to %[[VAL_29]] step %[[VAL_33]] { 881! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_19]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>> 882! CHECK: %[[VAL_36:.*]] = fir.coordinate_of %[[VAL_35]], %[[VAL_34]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>> 883! CHECK: fir.store %[[VAL_32]] to %[[VAL_36]] : !fir.ref<!fir.char<1>> 884! CHECK: } 885! CHECK: %[[VAL_37:.*]] = fir.array_amend %[[VAL_17]], %[[VAL_19]] : (!fir.array<50x!fir.char<1,?>>, !fir.ref<!fir.char<1,?>>) -> !fir.array<50x!fir.char<1,?>> 886! CHECK: fir.result %[[VAL_37]] : !fir.array<50x!fir.char<1,?>> 887! CHECK: } 888! CHECK: fir.array_merge_store %[[VAL_9]], %[[VAL_38:.*]] to %[[VAL_3]] typeparams %[[VAL_2]]#1 : !fir.array<50x!fir.char<1,?>>, !fir.array<50x!fir.char<1,?>>, !fir.ref<!fir.array<50x!fir.char<1,?>>>, index 889! CHECK: return 890! CHECK: } 891 892subroutine test19e(a,b) 893 character(*) a(50) 894 character(*) b(50) 895 a = b 896end subroutine test19e 897 898! CHECK-LABEL: func @_QPtest19f( 899! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 900! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 901! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<60x!fir.char<1,?>>> 902! CHECK: %[[VAL_4:.*]] = arith.constant 60 : index 903! CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 904! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<60x!fir.char<1,?>>> 905! CHECK: %[[VAL_7:.*]] = arith.constant 60 : index 906! CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 907! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_3]](%[[VAL_8]]) typeparams %[[VAL_2]]#1 : (!fir.ref<!fir.array<60x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.array<60x!fir.char<1,?>> 908! CHECK: %[[VAL_10:.*]] = fir.address_of(@_QQcl.70726566697820) : !fir.ref<!fir.char<1,7>> 909! CHECK: %[[VAL_11:.*]] = arith.constant 7 : index 910! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1> 911! CHECK: %[[VAL_13:.*]] = fir.array_load %[[VAL_6]](%[[VAL_12]]) typeparams %[[VAL_5]]#1 : (!fir.ref<!fir.array<60x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.array<60x!fir.char<1,?>> 912! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index 913! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index 914! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_4]], %[[VAL_14]] : index 915! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_9]]) -> (!fir.array<60x!fir.char<1,?>>) { 916! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_13]], %[[VAL_18]] typeparams %[[VAL_5]]#1 : (!fir.array<60x!fir.char<1,?>>, index, index) -> !fir.ref<!fir.char<1,?>> 917! CHECK: %[[VAL_21:.*]] = arith.addi %[[VAL_11]], %[[VAL_5]]#1 : index 918! CHECK: %[[VAL_22:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_21]] : index) {bindc_name = ".chrtmp"} 919! CHECK: %[[VAL_23:.*]] = arith.constant 1 : i64 920! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_11]] : (index) -> i64 921! CHECK: %[[VAL_25:.*]] = arith.muli %[[VAL_23]], %[[VAL_24]] : i64 922! CHECK: %[[VAL_26:.*]] = arith.constant false 923! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 924! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_10]] : (!fir.ref<!fir.char<1,7>>) -> !fir.ref<i8> 925! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_27]], %[[VAL_28]], %[[VAL_25]], %[[VAL_26]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 926! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index 927! CHECK: %[[VAL_30:.*]] = arith.subi %[[VAL_21]], %[[VAL_29]] : index 928! CHECK: fir.do_loop %[[VAL_31:.*]] = %[[VAL_11]] to %[[VAL_30]] step %[[VAL_29]] { 929! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_31]], %[[VAL_11]] : index 930! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_20]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>> 931! CHECK: %[[VAL_34:.*]] = fir.coordinate_of %[[VAL_33]], %[[VAL_32]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>> 932! CHECK: %[[VAL_35:.*]] = fir.load %[[VAL_34]] : !fir.ref<!fir.char<1>> 933! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>> 934! CHECK: %[[VAL_37:.*]] = fir.coordinate_of %[[VAL_36]], %[[VAL_31]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>> 935! CHECK: fir.store %[[VAL_35]] to %[[VAL_37]] : !fir.ref<!fir.char<1>> 936! CHECK: } 937! CHECK: %[[VAL_38:.*]] = fir.array_access %[[VAL_19]], %[[VAL_18]] typeparams %[[VAL_2]]#1 : (!fir.array<60x!fir.char<1,?>>, index, index) -> !fir.ref<!fir.char<1,?>> 938! CHECK: %[[VAL_39:.*]] = arith.cmpi slt, %[[VAL_2]]#1, %[[VAL_21]] : index 939! CHECK: %[[VAL_40:.*]] = arith.select %[[VAL_39]], %[[VAL_2]]#1, %[[VAL_21]] : index 940! CHECK: %[[VAL_41:.*]] = arith.constant 1 : i64 941! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_40]] : (index) -> i64 942! CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_41]], %[[VAL_42]] : i64 943! CHECK: %[[VAL_44:.*]] = arith.constant false 944! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_38]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 945! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 946! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_45]], %[[VAL_46]], %[[VAL_43]], %[[VAL_44]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 947! CHECK: %[[VAL_47:.*]] = arith.constant 1 : index 948! CHECK: %[[VAL_48:.*]] = arith.subi %[[VAL_2]]#1, %[[VAL_47]] : index 949! CHECK: %[[VAL_49:.*]] = arith.constant 32 : i8 950! CHECK: %[[VAL_50:.*]] = fir.undefined !fir.char<1> 951! CHECK: %[[VAL_51:.*]] = fir.insert_value %[[VAL_50]], %[[VAL_49]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> 952! CHECK: %[[VAL_52:.*]] = arith.constant 1 : index 953! CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_40]] to %[[VAL_48]] step %[[VAL_52]] { 954! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_38]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>> 955! CHECK: %[[VAL_55:.*]] = fir.coordinate_of %[[VAL_54]], %[[VAL_53]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>> 956! CHECK: fir.store %[[VAL_51]] to %[[VAL_55]] : !fir.ref<!fir.char<1>> 957! CHECK: } 958! CHECK: %[[VAL_56:.*]] = fir.array_amend %[[VAL_19]], %[[VAL_38]] : (!fir.array<60x!fir.char<1,?>>, !fir.ref<!fir.char<1,?>>) -> !fir.array<60x!fir.char<1,?>> 959! CHECK: fir.result %[[VAL_56]] : !fir.array<60x!fir.char<1,?>> 960! CHECK: } 961! CHECK: fir.array_merge_store %[[VAL_9]], %[[VAL_57:.*]] to %[[VAL_3]] typeparams %[[VAL_2]]#1 : !fir.array<60x!fir.char<1,?>>, !fir.array<60x!fir.char<1,?>>, !fir.ref<!fir.array<60x!fir.char<1,?>>>, index 962! CHECK: return 963! CHECK: } 964 965subroutine test19f(a,b) 966 character(*) a(60) 967 character(*) b(60) 968 a = "prefix " // b 969end subroutine test19f 970 971! CHECK-LABEL: func @_QPtest19g( 972! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<4>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<2>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}) { 973! CHECK: %[[VAL_3:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<2>) -> (!fir.ref<!fir.char<2,?>>, index) 974! CHECK: %[[VAL_4:.*]] = arith.constant 13 : index 975! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_3]]#0 : (!fir.ref<!fir.char<2,?>>) -> !fir.ref<!fir.array<140x!fir.char<2,13>>> 976! CHECK: %[[VAL_6:.*]] = arith.constant 140 : index 977! CHECK: %[[VAL_7:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<4>) -> (!fir.ref<!fir.char<4,?>>, index) 978! CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 979! CHECK: %[[VAL_9:.*]] = arith.constant 0 : i32 980! CHECK: %[[VAL_10:.*]] = arith.cmpi sgt, %[[VAL_8]], %[[VAL_9]] : i32 981! CHECK: %[[VAL_11:.*]] = arith.select %[[VAL_10]], %[[VAL_8]], %[[VAL_9]] : i32 982! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_7]]#0 : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<!fir.array<70x!fir.char<4,?>>> 983! CHECK: %[[VAL_13:.*]] = arith.constant 70 : index 984! CHECK: %[[VAL_14:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1> 985! CHECK: %[[VAL_15:.*]] = fir.array_load %[[VAL_12]](%[[VAL_14]]) typeparams %[[VAL_11]] : (!fir.ref<!fir.array<70x!fir.char<4,?>>>, !fir.shape<1>, i32) -> !fir.array<70x!fir.char<4,?>> 986! CHECK: %[[VAL_16:.*]] = arith.constant 1 : i64 987! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i64) -> index 988! CHECK: %[[VAL_18:.*]] = arith.constant 2 : i64 989! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i64) -> index 990! CHECK: %[[VAL_20:.*]] = arith.constant 140 : i64 991! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i64) -> index 992! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> 993! CHECK: %[[VAL_23:.*]] = fir.slice %[[VAL_17]], %[[VAL_21]], %[[VAL_19]] : (index, index, index) -> !fir.slice<1> 994! CHECK: %[[VAL_24:.*]] = fir.array_load %[[VAL_5]](%[[VAL_22]]) {{\[}}%[[VAL_23]]] : (!fir.ref<!fir.array<140x!fir.char<2,13>>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<140x!fir.char<2,13>> 995! CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 996! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i32) -> i64 997! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index 998! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index 999! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_13]], %[[VAL_27]] : index 1000! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_15]]) -> (!fir.array<70x!fir.char<4,?>>) { 1001! CHECK: %[[VAL_33:.*]] = fir.array_access %[[VAL_24]], %[[VAL_31]] : (!fir.array<140x!fir.char<2,13>>, index) -> !fir.ref<!fir.char<2,13>> 1002! CHECK: %[[VAL_34:.*]] = fir.alloca !fir.char<4,?>(%[[VAL_4]] : index) 1003! CHECK: %[[VAL_35:.*]] = arith.cmpi slt, %[[VAL_4]], %[[VAL_4]] : index 1004! CHECK: %[[VAL_36:.*]] = arith.select %[[VAL_35]], %[[VAL_4]], %[[VAL_4]] : index 1005! CHECK: fir.char_convert %[[VAL_33]] for %[[VAL_36]] to %[[VAL_34]] : !fir.ref<!fir.char<2,13>>, index, !fir.ref<!fir.char<4,?>> 1006! CHECK: %[[VAL_37:.*]] = arith.constant 1 : index 1007! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_4]], %[[VAL_37]] : index 1008! CHECK: %[[VAL_39:.*]] = arith.constant 32 : i32 1009! CHECK: %[[VAL_40:.*]] = fir.undefined !fir.char<4> 1010! CHECK: %[[VAL_41:.*]] = fir.insert_value %[[VAL_40]], %[[VAL_39]], [0 : index] : (!fir.char<4>, i32) -> !fir.char<4> 1011! CHECK: %[[VAL_42:.*]] = arith.constant 1 : index 1012! CHECK: fir.do_loop %[[VAL_43:.*]] = %[[VAL_36]] to %[[VAL_38]] step %[[VAL_42]] { 1013! CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<!fir.array<?x!fir.char<4>>> 1014! CHECK: %[[VAL_45:.*]] = fir.coordinate_of %[[VAL_44]], %[[VAL_43]] : (!fir.ref<!fir.array<?x!fir.char<4>>>, index) -> !fir.ref<!fir.char<4>> 1015! CHECK: fir.store %[[VAL_41]] to %[[VAL_45]] : !fir.ref<!fir.char<4>> 1016! CHECK: } 1017! CHECK: %[[VAL_46:.*]] = fir.array_access %[[VAL_32]], %[[VAL_31]] typeparams %[[VAL_11]] : (!fir.array<70x!fir.char<4,?>>, index, i32) -> !fir.ref<!fir.char<4,?>> 1018! CHECK: %[[VAL_47:.*]] = fir.convert %[[VAL_11]] : (i32) -> index 1019! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_26]] : (i64) -> index 1020! CHECK: %[[VAL_49:.*]] = arith.cmpi slt, %[[VAL_47]], %[[VAL_48]] : index 1021! CHECK: %[[VAL_50:.*]] = arith.select %[[VAL_49]], %[[VAL_47]], %[[VAL_48]] : index 1022! CHECK: %[[VAL_51:.*]] = arith.constant 4 : i64 1023! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_50]] : (index) -> i64 1024! CHECK: %[[VAL_53:.*]] = arith.muli %[[VAL_51]], %[[VAL_52]] : i64 1025! CHECK: %[[VAL_54:.*]] = arith.constant false 1026! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_46]] : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<i8> 1027! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<i8> 1028! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_55]], %[[VAL_56]], %[[VAL_53]], %[[VAL_54]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 1029! CHECK: %[[VAL_57:.*]] = arith.constant 1 : i32 1030! CHECK: %[[VAL_58:.*]] = arith.subi %[[VAL_11]], %[[VAL_57]] : i32 1031! CHECK: %[[VAL_59:.*]] = arith.constant 32 : i32 1032! CHECK: %[[VAL_60:.*]] = fir.undefined !fir.char<4> 1033! CHECK: %[[VAL_61:.*]] = fir.insert_value %[[VAL_60]], %[[VAL_59]], [0 : index] : (!fir.char<4>, i32) -> !fir.char<4> 1034! CHECK: %[[VAL_62:.*]] = arith.constant 1 : index 1035! CHECK: %[[VAL_63:.*]] = fir.convert %[[VAL_58]] : (i32) -> index 1036! CHECK: fir.do_loop %[[VAL_64:.*]] = %[[VAL_50]] to %[[VAL_63]] step %[[VAL_62]] { 1037! CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_46]] : (!fir.ref<!fir.char<4,?>>) -> !fir.ref<!fir.array<?x!fir.char<4>>> 1038! CHECK: %[[VAL_66:.*]] = fir.coordinate_of %[[VAL_65]], %[[VAL_64]] : (!fir.ref<!fir.array<?x!fir.char<4>>>, index) -> !fir.ref<!fir.char<4>> 1039! CHECK: fir.store %[[VAL_61]] to %[[VAL_66]] : !fir.ref<!fir.char<4>> 1040! CHECK: } 1041! CHECK: %[[VAL_67:.*]] = fir.array_amend %[[VAL_32]], %[[VAL_46]] : (!fir.array<70x!fir.char<4,?>>, !fir.ref<!fir.char<4,?>>) -> !fir.array<70x!fir.char<4,?>> 1042! CHECK: fir.result %[[VAL_67]] : !fir.array<70x!fir.char<4,?>> 1043! CHECK: } 1044! CHECK: fir.array_merge_store %[[VAL_15]], %[[VAL_68:.*]] to %[[VAL_12]] typeparams %[[VAL_11]] : !fir.array<70x!fir.char<4,?>>, !fir.array<70x!fir.char<4,?>>, !fir.ref<!fir.array<70x!fir.char<4,?>>>, i32 1045! CHECK: return 1046! CHECK: } 1047 1048subroutine test19g(a,b,i) 1049 character(kind=4,len=i) a(70) 1050 character(kind=2,len=13) b(140) 1051 a = b(1:140:2) 1052end subroutine test19g 1053 1054! CHECK-LABEL: func @_QPtest19h( 1055! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}, %[[VAL_3:.*]]: !fir.ref<i32>{{.*}}) { 1056! CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 1057! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> 1058! CHECK: %[[VAL_6:.*]] = arith.constant 0 : i32 1059! CHECK: %[[VAL_7:.*]] = arith.cmpi sgt, %[[VAL_5]], %[[VAL_6]] : i32 1060! CHECK: %[[VAL_8:.*]] = arith.select %[[VAL_7]], %[[VAL_5]], %[[VAL_6]] : i32 1061! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<70x!fir.char<1,?>>> 1062! CHECK: %[[VAL_10:.*]] = arith.constant 70 : index 1063! CHECK: %[[VAL_11:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 1064! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1,?>>> 1065! CHECK: %[[VAL_13:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> 1066! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i32) -> i64 1067! CHECK: %[[VAL_15A:.*]] = fir.convert %[[VAL_14]] : (i64) -> index 1068! CHECK: %[[C0:.*]] = arith.constant 0 : index 1069! CHECK: %[[CMP:.*]] = arith.cmpi sgt, %[[VAL_15A]], %[[C0]] : index 1070! CHECK: %[[VAL_15:.*]] = arith.select %[[CMP]], %[[VAL_15A]], %[[C0]] : index 1071! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1> 1072! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_9]](%[[VAL_16]]) typeparams %[[VAL_8]] : (!fir.ref<!fir.array<70x!fir.char<1,?>>>, !fir.shape<1>, i32) -> !fir.array<70x!fir.char<1,?>> 1073! CHECK: %[[VAL_18:.*]] = arith.constant 1 : i64 1074! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i64) -> index 1075! CHECK: %[[VAL_20:.*]] = arith.constant 2 : i64 1076! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i64) -> index 1077! CHECK: %[[VAL_22:.*]] = arith.constant 140 : i64 1078! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (i64) -> index 1079! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1> 1080! CHECK: %[[VAL_25:.*]] = fir.slice %[[VAL_19]], %[[VAL_23]], %[[VAL_21]] : (index, index, index) -> !fir.slice<1> 1081! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_12]](%[[VAL_24]]) {{\[}}%[[VAL_25]]] typeparams %[[VAL_11]]#1 : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.array<?x!fir.char<1,?>> 1082! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index 1083! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index 1084! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_10]], %[[VAL_27]] : index 1085! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_17]]) -> (!fir.array<70x!fir.char<1,?>>) { 1086! CHECK: %[[VAL_33:.*]] = fir.array_access %[[VAL_26]], %[[VAL_31]] typeparams %[[VAL_11]]#1 : (!fir.array<?x!fir.char<1,?>>, index, index) -> !fir.ref<!fir.char<1,?>> 1087! CHECK: %[[VAL_34:.*]] = fir.array_access %[[VAL_32]], %[[VAL_31]] typeparams %[[VAL_8]] : (!fir.array<70x!fir.char<1,?>>, index, i32) -> !fir.ref<!fir.char<1,?>> 1088! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_8]] : (i32) -> index 1089! CHECK: %[[VAL_36:.*]] = arith.cmpi slt, %[[VAL_35]], %[[VAL_11]]#1 : index 1090! CHECK: %[[VAL_37:.*]] = arith.select %[[VAL_36]], %[[VAL_35]], %[[VAL_11]]#1 : index 1091! CHECK: %[[VAL_38:.*]] = arith.constant 1 : i64 1092! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (index) -> i64 1093! CHECK: %[[VAL_40:.*]] = arith.muli %[[VAL_38]], %[[VAL_39]] : i64 1094! CHECK: %[[VAL_41:.*]] = arith.constant false 1095! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 1096! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_33]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 1097! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_42]], %[[VAL_43]], %[[VAL_40]], %[[VAL_41]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> () 1098! CHECK: %[[VAL_44:.*]] = arith.constant 1 : i32 1099! CHECK: %[[VAL_45:.*]] = arith.subi %[[VAL_8]], %[[VAL_44]] : i32 1100! CHECK: %[[VAL_46:.*]] = arith.constant 32 : i8 1101! CHECK: %[[VAL_47:.*]] = fir.undefined !fir.char<1> 1102! CHECK: %[[VAL_48:.*]] = fir.insert_value %[[VAL_47]], %[[VAL_46]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> 1103! CHECK: %[[VAL_49:.*]] = arith.constant 1 : index 1104! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_45]] : (i32) -> index 1105! CHECK: fir.do_loop %[[VAL_51:.*]] = %[[VAL_37]] to %[[VAL_50]] step %[[VAL_49]] { 1106! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>> 1107! CHECK: %[[VAL_53:.*]] = fir.coordinate_of %[[VAL_52]], %[[VAL_51]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>> 1108! CHECK: fir.store %[[VAL_48]] to %[[VAL_53]] : !fir.ref<!fir.char<1>> 1109! CHECK: } 1110! CHECK: %[[VAL_54:.*]] = fir.array_amend %[[VAL_32]], %[[VAL_34]] : (!fir.array<70x!fir.char<1,?>>, !fir.ref<!fir.char<1,?>>) -> !fir.array<70x!fir.char<1,?>> 1111! CHECK: fir.result %[[VAL_54]] : !fir.array<70x!fir.char<1,?>> 1112! CHECK: } 1113! CHECK: fir.array_merge_store %[[VAL_17]], %[[VAL_55:.*]] to %[[VAL_9]] typeparams %[[VAL_8]] : !fir.array<70x!fir.char<1,?>>, !fir.array<70x!fir.char<1,?>>, !fir.ref<!fir.array<70x!fir.char<1,?>>>, i32 1114! CHECK: return 1115! CHECK: } 1116 1117subroutine test19h(a,b,i,j) 1118 character(i) a(70) 1119 character(*) b(j) 1120 a = b(1:140:2) 1121end subroutine test19h 1122 1123! CHECK-LABEL: func @_QPtest_elemental_character_intrinsic( 1124! CHECK-SAME: %[[VAL_0:.*]]: !fir.boxchar<1>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) { 1125! CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 1126! CHECK: %[[VAL_3:.*]] = fir.convert %[[VAL_2]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,?>>> 1127! CHECK: %[[VAL_4:.*]] = arith.constant 10 : index 1128! CHECK: %[[VAL_5:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index) 1129! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,?>>> 1130! CHECK: %[[VAL_7:.*]] = arith.constant 2 : index 1131! CHECK: %[[VAL_8:.*]] = arith.constant 10 : index 1132! CHECK: %[[VAL_9:.*]] = arith.constant -1 : i32 1133! CHECK: %[[VAL_10:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1, 1134! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8> 1135! CHECK: %[[VAL_12:.*]] = arith.constant {{.*}} : i32 1136! CHECK: %[[VAL_13:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_9]], %[[VAL_11]], %[[VAL_12]]) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8> 1137! CHECK: %[[VAL_15:.*]] = arith.constant 10 : index 1138! CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> 1139! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_7]], %[[VAL_8]] : (index, index) -> !fir.shapeshift<1> 1140! CHECK: %[[VAL_18:.*]] = fir.allocmem !fir.array<10xi32> 1141! CHECK: %[[VAL_19:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1> 1142! CHECK: %[[VAL_20:.*]] = fir.array_load %[[VAL_18]](%[[VAL_19]]) : (!fir.heap<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32> 1143! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index 1144! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index 1145! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_15]], %[[VAL_21]] : index 1146! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array<10xi32>) { 1147! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index 1148! CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_25]], %[[VAL_27]] : index 1149! CHECK: %[[VAL_29:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_16]]) %[[VAL_28]] typeparams %[[VAL_2]]#1 : (!fir.ref<!fir.array<10x!fir.char<1,?>>>, !fir.shape<1>, index, index) -> !fir.ref<!fir.char<1,?>> 1150! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_25]], %[[VAL_7]] : index 1151! CHECK: %[[VAL_31:.*]] = fir.array_coor %[[VAL_6]](%[[VAL_17]]) %[[VAL_30]] typeparams %[[VAL_5]]#1 : (!fir.ref<!fir.array<10x!fir.char<1,?>>>, !fir.shapeshift<1>, index, index) -> !fir.ref<!fir.char<1,?>> 1152! CHECK: %[[VAL_32:.*]] = arith.constant false 1153! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_29]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 1154! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_2]]#1 : (index) -> i64 1155! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_31]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8> 1156! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_5]]#1 : (index) -> i64 1157! CHECK: %[[VAL_37:.*]] = fir.call @_FortranAScan1(%[[VAL_33]], %[[VAL_34]], %[[VAL_35]], %[[VAL_36]], %[[VAL_32]]) : (!fir.ref<i8>, i64, !fir.ref<i8>, i64, i1) -> i64 1158! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_37]] : (i64) -> i32 1159! CHECK: %[[VAL_39:.*]] = fir.array_update %[[VAL_26]], %[[VAL_38]], %[[VAL_25]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32> 1160! CHECK: fir.result %[[VAL_39]] : !fir.array<10xi32> 1161! CHECK: } 1162! CHECK: fir.array_merge_store %[[VAL_20]], %[[VAL_40:.*]] to %[[VAL_18]] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.heap<!fir.array<10xi32>> 1163! CHECK: %[[VAL_41:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1> 1164! CHECK: %[[VAL_42:.*]] = fir.embox %[[VAL_18]](%[[VAL_41]]) : (!fir.heap<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>> 1165! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none> 1166! CHECK: %[[VAL_44:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_13]], %[[VAL_43]]) : (!fir.ref<i8>, !fir.box<none>) -> i1 1167! CHECK: fir.freemem %[[VAL_18]] : !fir.heap<!fir.array<10xi32>> 1168! CHECK: %[[VAL_45:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_13]]) : (!fir.ref<i8>) -> i32 1169! CHECK: return 1170! CHECK: } 1171 1172subroutine test_elemental_character_intrinsic(c1, c2) 1173 character(*) :: c1(10), c2(2:11) 1174 print *, scan(c1, c2) 1175end subroutine 1176 1177! CHECK: func private @_QPbar( 1178