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 18 end subroutine test1 19 20 ! CHECK-LABEL: func @_QPtest1b 21 subroutine 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 38 end 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: } 60 subroutine test2(a,b,c) 61 real, intent(out) :: a(:) 62 real, intent(in) :: b(:), c(:) 63 a = b + c 64 end subroutine test2 65 66 ! CHECK-LABEL: func @_QPtest3 67 subroutine 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 81 end subroutine test3 82 83 ! CHECK-LABEL: func @_QPtest4 84 subroutine 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 96 end subroutine test4 97 98 ! CHECK-LABEL: func @_QPtest5 99 subroutine 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 112 end 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 154 subroutine 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 159 end 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 194 subroutine 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) 199 end 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 240 subroutine 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 245 end 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. 277 subroutine test7(a,b,n) 278 integer :: n 279 real, intent(inout) :: a(n) 280 real, intent(in) :: b(n) 281 a = a + b 282 end 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 305 subroutine test8(a,b) 306 integer :: a(100), b(100) 307 a = b(1) 308 end subroutine test8 309 310 subroutine 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))) 327 end 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 374 subroutine 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) 378 end subroutine test11 379 380 ! CHECK-LABEL: func @_QPtest12 381 subroutine 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]] 405 end subroutine test12 406 407 ! CHECK-LABEL: func @_QPtest13 408 subroutine 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 430 end 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>>{{.*}}) 435 subroutine 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) 451 end 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>>{{.*}}) 456 subroutine 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) 467 end 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>>{{.*}}) 472 subroutine 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) 490 end 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>>{{.*}}) 496 subroutine 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]] 526 end 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 555 subroutine test18 556 integer, target :: array(10,10) 557 integer, pointer :: row_i(:) 558 row_i => array(i, :) 559 end 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 584 subroutine test_column_and_row_order(x) 585 real :: x(2,3) 586 x = 42 587 end 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 618 subroutine test_assigning_to_assumed_shape_slices(x) 619 integer :: x(:) 620 x(::2) = 42 621 end 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 656 subroutine test19a(a,b) 657 character(LEN=10) a(10) 658 character(LEN=10) b(10) 659 a = b 660 end 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 709 subroutine test19b(a,b) 710 character(KIND=2, LEN=8) a(20) 711 character(KIND=2, LEN=10) b(20) 712 a = b 713 end 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 767 subroutine test19c(a,b,i) 768 character(KIND=4, LEN=i) a(30) 769 character(KIND=4, LEN=10) b(30) 770 a = b 771 end 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 829 subroutine test19d(a,b,i,j) 830 character(i) a(40) 831 character(j) b(40) 832 a = b 833 end 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 880 subroutine test19e(a,b) 881 character(*) a(50) 882 character(*) b(50) 883 a = b 884 end 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 953 subroutine test19f(a,b) 954 character(*) a(60) 955 character(*) b(60) 956 a = "prefix " // b 957 end 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 1036 subroutine 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) 1040 end 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 1102 subroutine test19h(a,b,i,j) 1103 character(i) a(70) 1104 character(*) b(j) 1105 a = b(1:140:2) 1106 end 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 1157 subroutine test_elemental_character_intrinsic(c1, c2) 1158 character(*) :: c1(10), c2(2:11) 1159 print *, scan(c1, c2) 1160 end subroutine 1161 1162 ! CHECK: func private @_QPbar( 1163