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