| blob | 2f7c439ed3f4e13359926f795284303df0138a20 |
1 // RUN: fir-opt --loop-versioning %s | FileCheck %s
4 // subroutine sum1d(a, n)
5 // real*8 :: a(:)
6 // integer :: n
7 // real*8 :: sum
8 // integer :: i
9 // sum = 0
10 // do i=1,n
11 // sum = sum + a(i)
12 // end do
13 // end subroutine sum1d
14 module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<f80, dense<128> : vector<2xi64>>, #dlti.dl_entry<i128, dense<128> : vector<2xi64>>, #dlti.dl_entry<i64, dense<64> : vector<2xi64>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi64>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi64>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi64>>, #dlti.dl_entry<f128, dense<128> : vector<2xi64>>, #dlti.dl_entry<f64, dense<64> : vector<2xi64>>, #dlti.dl_entry<f16, dense<16> : vector<2xi64>>, #dlti.dl_entry<i32, dense<32> : vector<2xi64>>, #dlti.dl_entry<i16, dense<16> : vector<2xi64>>, #dlti.dl_entry<i8, dense<8> : vector<2xi64>>, #dlti.dl_entry<i1, dense<8> : vector<2xi64>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi64>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i64>>} {
15 func.func @sum1d(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {
16 %decl = fir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
17 %rebox = fir.rebox %decl : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
18 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMmoduleFsum1dEi"}
19 %1 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QMmoduleFsum1dEsum"}
20 %cst = arith.constant 0.000000e+00 : f64
21 fir.store %cst to %1 : !fir.ref<f64>
22 %c1_i32 = arith.constant 1 : i32
23 %2 = fir.convert %c1_i32 : (i32) -> index
24 %3 = fir.load %arg1 : !fir.ref<i32>
25 %4 = fir.convert %3 : (i32) -> index
26 %c1 = arith.constant 1 : index
27 %5 = fir.convert %2 : (index) -> i32
28 %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) {
29 fir.store %arg3 to %0 : !fir.ref<i32>
30 %7 = fir.load %1 : !fir.ref<f64>
31 %8 = fir.load %0 : !fir.ref<i32>
32 %9 = fir.convert %8 : (i32) -> i64
33 %c1_i64 = arith.constant 1 : i64
34 %10 = arith.subi %9, %c1_i64 : i64
35 %11 = fir.coordinate_of %rebox, %10 : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64>
36 %12 = fir.load %11 : !fir.ref<f64>
37 %13 = arith.addf %7, %12 fastmath<contract> : f64
38 fir.store %13 to %1 : !fir.ref<f64>
39 %14 = arith.addi %arg2, %c1 : index
40 %15 = fir.convert %c1 : (index) -> i32
41 %16 = fir.load %0 : !fir.ref<i32>
42 %17 = arith.addi %16, %15 : i32
43 fir.result %14, %17 : index, i32
44 }
45 fir.store %6#1 to %0 : !fir.ref<i32>
46 return
47 }
49 // Note this only checks the expected transformation, not the entire generated code:
50 // CHECK-LABEL: func.func @sum1d(
51 // CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xf64>> {{.*}})
52 // CHECK: %[[DECL:.*]] = fir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
53 // CHECK: %[[REBOX:.*]] = fir.rebox %[[DECL]]
54 // CHECK: %[[ZERO:.*]] = arith.constant 0 : index
55 // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[REBOX]], %[[ZERO]] : {{.*}}
56 // CHECK: %[[SIZE:.*]] = arith.constant 8 : index
57 // CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[DIMS]]#2, %[[SIZE]]
58 // CHECK: %[[IF_RES:.*]]:2 = fir.if %[[CMP]] -> {{.*}}
59 // CHECK: %[[NEWARR:.*]] = fir.convert %[[REBOX]]
60 // CHECK: %[[BOXADDR:.*]] = fir.box_addr %[[NEWARR]] : {{.*}} -> !fir.ref<!fir.array<?xf64>>
61 // CHECK: %[[LOOP_RES:.*]]:2 = fir.do_loop {{.*}}
62 // CHECK: %[[COORD:.*]] = fir.coordinate_of %[[BOXADDR]], %{{.*}} : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
63 // CHECK: %{{.*}} = fir.load %[[COORD]] : !fir.ref<f64>
64 // CHECK: fir.result %{{.*}}, %{{.*}}
65 // CHECK: }
66 // CHECK fir.result %[[LOOP_RES]]#0, %[[LOOP_RES]]#1
67 // CHECK: } else {
68 // CHECK: %[[LOOP_RES2:.*]]:2 = fir.do_loop {{.*}}
69 // CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[REBOX]], %{{.*}} : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64>
70 // CHECK: %{{.*}}= fir.load %[[COORD2]] : !fir.ref<f64>
71 // CHECK: fir.result %{{.*}}, %{{.*}}
72 // CHECK: }
73 // CHECK fir.result %[[LOOP_RES2]]#0, %[[LOOP_RES2]]#1
74 // CHECK: }
75 // CHECK: fir.store %[[IF_RES]]#1 to %{{.*}}
76 // CHECK: return
78 // -----
80 // Test that loop-versioning pass doesn't expand known size arrays.
81 func.func @sum1dfixed(%arg0: !fir.ref<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {
82 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum1dfixedEi"}
83 %1 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum1dfixedEsum"}
84 %cst = arith.constant 0.000000e+00 : f64
85 fir.store %cst to %1 : !fir.ref<f64>
86 %c1_i32 = arith.constant 1 : i32
87 %2 = fir.convert %c1_i32 : (i32) -> index
88 %3 = fir.load %arg1 : !fir.ref<i32>
89 %4 = fir.convert %3 : (i32) -> index
90 %c1 = arith.constant 1 : index
91 %5 = fir.convert %2 : (index) -> i32
92 %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) {
93 fir.store %arg3 to %0 : !fir.ref<i32>
94 %7 = fir.load %1 : !fir.ref<f64>
95 %8 = fir.load %0 : !fir.ref<i32>
96 %9 = fir.convert %8 : (i32) -> i64
97 %c1_i64 = arith.constant 1 : i64
98 %10 = arith.subi %9, %c1_i64 : i64
99 %11 = fir.coordinate_of %arg0, %10 : (!fir.ref<!fir.array<?xf64>>, i64) -> !fir.ref<f64>
100 %12 = fir.load %11 : !fir.ref<f64>
101 %13 = arith.addf %7, %12 fastmath<contract> : f64
102 fir.store %13 to %1 : !fir.ref<f64>
103 %14 = arith.addi %arg2, %c1 : index
104 %15 = fir.convert %c1 : (index) -> i32
105 %16 = fir.load %0 : !fir.ref<i32>
106 %17 = arith.addi %16, %15 : i32
107 fir.result %14, %17 : index, i32
108 }
109 fir.store %6#1 to %0 : !fir.ref<i32>
110 return
111 }
113 // CHECK-LABEL: func.func @sum1dfixed(
114 // CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.array<?xf64>> {{.*}})
115 // CHECK: fir.do_loop {{.*}}
116 // CHECK-NOT: fir.do_loop
117 // CHECK: %[[COORD:.*]] = fir.coordinate_of %[[ARG0]], {{.*}}
118 // CHECK: %{{.*}} = fir.load %[[COORD]]
119 // CHECK-NOT: fir.do_loop
121 // -----
123 // Check that "no result" from a versioned loop works correctly
124 // This code was the basis for this, but `read` is replaced with a function called Func
125 // subroutine test3(x, y)
126 // integer :: y(:)
127 // integer :: x(:)
128 // read(*,*) x(y)
129 // end subroutine
131 func.func @test3(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "y"}) {
132 %c0 = arith.constant 0 : index
133 %3:3 = fir.box_dims %arg1, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
134 %c1 = arith.constant 1 : index
135 %4 = fir.slice %c1, %3#1, %c1 : (index, index, index) -> !fir.slice<1>
136 %c1_0 = arith.constant 1 : index
137 %c0_1 = arith.constant 0 : index
138 %5 = arith.subi %3#1, %c1_0 : index
139 fir.do_loop %arg2 = %c0_1 to %5 step %c1_0 {
140 %7 = fir.coordinate_of %arg1, %arg2 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
141 %8 = fir.load %7 : !fir.ref<i32>
142 %9 = fir.convert %8 : (i32) -> index
143 %10 = fir.array_coor %arg0 [%4] %9 : (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index) -> !fir.ref<i32>
144 %12 = fir.call @Func(%10) fastmath<contract> : (!fir.ref<i32>) -> i1
145 }
146 return
147 }
148 func.func private @Func(!fir.ref<i8>, !fir.ref<i32>) -> i1
150 // CHECK-LABEL: func.func @test3(
151 // CHECK-SAME: %[[X:.*]]: !fir.box<!fir.array<?xi32>> {{.*}},
152 // CHECK-SAME: %[[Y:.*]]: !fir.box<!fir.array<?xi32>> {{.*}}) {
153 // Look for arith.subi to locate the correct part of code.
154 // CHECK: {{.*}} arith.subi {{.*}}
155 // CHECK: %[[ZERO:.*]] = arith.constant 0 : index
156 // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[Y]], %[[ZERO]]
157 // CHECK: %[[FOUR:.*]] = arith.constant 4 : index
158 // CHECK: %[[COMP:.*]] = arith.cmpi eq, %[[DIMS]]#2, %[[FOUR]] : index
159 // CHECK: fir.if %[[COMP]] {
160 // CHECK: %[[CONV:.*]] = fir.convert %[[Y]] : {{.*}}
161 // CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[CONV]] : {{.*}}
162 // CHECK: fir.do_loop %[[INDEX:.*]] = {{.*}}
163 // CHECK: %[[YADDR:.*]] = fir.coordinate_of %[[BOX_ADDR]], %[[INDEX]]
164 // CHECK: %[[YINT:.*]] = fir.load %[[YADDR]] : {{.*}}
165 // CHECK: %[[YINDEX:.*]] = fir.convert %[[YINT]]
166 // CHECK: %[[XADDR:.*]] = fir.array_coor %[[X]] [%{{.*}}] %[[YINDEX]]
167 // CHECK: fir.call @Func(%[[XADDR]])
168 // CHECK-NEXT: }
169 // CHECK-NEXT: } else {
170 // CHECK: fir.do_loop %[[INDEX2:.*]] = {{.*}}
171 // CHECK: %[[YADDR2:.*]] = fir.coordinate_of %[[Y]], %[[INDEX2]]
172 // CHECK: %[[YINT2:.*]] = fir.load %[[YADDR2]] : {{.*}}
173 // CHECK: %[[YINDEX2:.*]] = fir.convert %[[YINT2]]
174 // CHECK: %[[XADDR2:.*]] = fir.array_coor %[[X]] [%{{.*}}] %[[YINDEX2]]
175 // CHECK: fir.call @Func(%[[XADDR2]])
176 // CHECK-NEXT: }
179 // ----
181 // Test array initialization.
182 //
183 // This code has been modified to simplify it - removing the realloc generated to grow
184 // the constructed
185 //subroutine test4(a, b, n1, m1)
186 // real :: a(:)
187 // real :: b(:,:)
188 //
189 // a = [ ((b(i,j), j=1,n1,m1), i=1,n1,m1) ]
190 //end subroutine test4
192 func.func @test4(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "b"}, %arg2: !fir.ref<i32> {fir.bindc_name = "n1"}, %arg3: !fir.ref<i32> {fir.bindc_name = "m1"}) {
193 %0 = fir.alloca index {bindc_name = ".buff.pos"}
194 %1 = fir.alloca index {bindc_name = ".buff.size"}
195 %c0 = arith.constant 0 : index
196 %2:3 = fir.box_dims %arg0, %c0 : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
197 %3 = fir.array_load %arg0 : (!fir.box<!fir.array<?xf32>>) -> !fir.array<?xf32>
198 %c0_0 = arith.constant 0 : index
199 fir.store %c0_0 to %0 : !fir.ref<index>
200 %c32 = arith.constant 32 : index
201 %4 = fir.allocmem f32, %c32
202 fir.store %c32 to %1 : !fir.ref<index>
203 %c1_i64 = arith.constant 1 : i64
204 %5 = fir.convert %c1_i64 : (i64) -> index
205 %6 = fir.load %arg2 : !fir.ref<i32>
206 %7 = fir.convert %6 : (i32) -> i64
207 %8 = fir.convert %7 : (i64) -> index
208 %9 = fir.load %arg3 : !fir.ref<i32>
209 %10 = fir.convert %9 : (i32) -> i64
210 %11 = fir.convert %10 : (i64) -> index
211 %12 = fir.do_loop %arg4 = %5 to %8 step %11 iter_args(%arg5 = %4) -> (!fir.heap<f32>) {
212 %c1_i64_2 = arith.constant 1 : i64
213 %19 = fir.convert %c1_i64_2 : (i64) -> index
214 %20 = fir.load %arg2 : !fir.ref<i32>
215 %21 = fir.convert %20 : (i32) -> i64
216 %22 = fir.convert %21 : (i64) -> index
217 %23 = fir.load %arg3 : !fir.ref<i32>
218 %24 = fir.convert %23 : (i32) -> i64
219 %25 = fir.convert %24 : (i64) -> index
220 %26 = fir.do_loop %arg6 = %19 to %22 step %25 iter_args(%arg7 = %arg5) -> (!fir.heap<f32>) {
221 %27 = fir.convert %arg4 : (index) -> i32
222 %28 = fir.convert %27 : (i32) -> i64
223 %c1_i64_3 = arith.constant 1 : i64
224 %29 = arith.subi %28, %c1_i64_3 : i64
225 %30 = fir.convert %arg6 : (index) -> i32
226 %31 = fir.convert %30 : (i32) -> i64
227 %c1_i64_4 = arith.constant 1 : i64
228 %32 = arith.subi %31, %c1_i64_4 : i64
229 %33 = fir.coordinate_of %arg1, %29, %32 : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
230 %34 = fir.load %33 : !fir.ref<f32>
231 %c1_5 = arith.constant 1 : index
232 %35 = fir.zero_bits !fir.ref<!fir.array<?xf32>>
233 %36 = fir.coordinate_of %35, %c1_5 : (!fir.ref<!fir.array<?xf32>>, index) -> !fir.ref<f32>
234 %37 = fir.convert %36 : (!fir.ref<f32>) -> index
235 %38 = fir.load %0 : !fir.ref<index>
236 %39 = fir.load %1 : !fir.ref<index>
237 %c1_6 = arith.constant 1 : index
238 %40 = arith.addi %38, %c1_6 : index
240 fir.store %40 to %0 : !fir.ref<index>
241 fir.result %arg7 : !fir.heap<f32>
242 }
243 fir.result %26 : !fir.heap<f32>
244 }
245 %13 = fir.convert %12 : (!fir.heap<f32>) -> !fir.heap<!fir.array<?xf32>>
246 %14 = fir.load %0 : !fir.ref<index>
247 %15 = fir.shape %14 : (index) -> !fir.shape<1>
248 %16 = fir.array_load %13(%15) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
249 %c1 = arith.constant 1 : index
250 %c0_1 = arith.constant 0 : index
251 %17 = arith.subi %2#1, %c1 : index
252 %18 = fir.do_loop %arg4 = %c0_1 to %17 step %c1 unordered iter_args(%arg5 = %3) -> (!fir.array<?xf32>) {
253 %19 = fir.array_fetch %16, %arg4 : (!fir.array<?xf32>, index) -> f32
254 %20 = fir.array_update %arg5, %19, %arg4 : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
255 fir.result %20 : !fir.array<?xf32>
256 }
257 fir.array_merge_store %3, %18 to %arg0 : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.array<?xf32>>
258 fir.freemem %13 : !fir.heap<!fir.array<?xf32>>
259 return
260 }
262 // CHECK: func.func @test4(
263 // CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<?xf32>>
264 // CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?x?xf32>>
265 // CHECK-SAME: %[[N1:.*]]: !fir.ref<i32> {{.*}},
266 // CHECK-SAME: %[[M1:.*]]: !fir.ref<i32> {{.*}}) {
267 // CHECK: fir.do_loop
268 // CHECK: %[[FOUR:.*]] = arith.constant 4 : index
269 // CHECK: %[[COMP:.*]] = arith.cmpi {{.*}}, %[[FOUR]]
270 // CHECK: fir.if %[[COMP]] -> {{.*}} {
271 // CHECK: %[[CONV:.*]] = fir.convert %[[B]] :
272 // CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[CONV]]
273 // CHECK: %[[RES:.*]] = fir.do_loop {{.*}} {
274 // CHECK: %[[ADDR:.*]] = fir.coordinate_of %[[BOX_ADDR]], %{{.*}}
275 // CHECK: %{{.*}} = fir.load %[[ADDR]] : !fir.ref<f32>
276 // CHECK: }
277 // CHECK: fir.result %[[RES]] : {{.*}}
278 // CHECK: } else {
279 // CHECK: %[[RES2:.*]] = fir.do_loop
280 // CHECK: %{{.*}} = fir.coordinate_of %[[B]], %{{.*}}
281 // CHECK: }
282 // CHECK: fir.result %[[RES2]]
283 // CHECK: }
285 // -----
288 // Check that 2D arrays are identified and converted.
289 // Source code:
290 // subroutine sum2d(a, nx, ny)
291 // real*8 :: a(:,:)
292 // integer :: nx, ny
293 // real*8 :: sum
294 // integer :: i, j
295 // sum = 0
296 // do i=1,nx
297 // do j=1,ny
298 // sum = sum + a(j,i)
299 // end do
300 // end do
301 // end subroutine sum2d
303 func.func @sum2d(%arg0: !fir.box<!fir.array<?x?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "nx"}, %arg2: !fir.ref<i32> {fir.bindc_name = "ny"}) {
304 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMmoduleFsum2dEi"}
305 %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QMmoduleFsum2dEj"}
306 %2 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QMmoduleFsum2dEsum"}
307 %cst = arith.constant 0.000000e+00 : f64
308 fir.store %cst to %2 : !fir.ref<f64>
309 %c1_i32 = arith.constant 1 : i32
310 %3 = fir.convert %c1_i32 : (i32) -> index
311 %4 = fir.load %arg1 : !fir.ref<i32>
312 %5 = fir.convert %4 : (i32) -> index
313 %c1 = arith.constant 1 : index
314 %6 = fir.convert %3 : (index) -> i32
315 %7:2 = fir.do_loop %arg3 = %3 to %5 step %c1 iter_args(%arg4 = %6) -> (index, i32) {
316 fir.store %arg4 to %0 : !fir.ref<i32>
317 %c1_i32_0 = arith.constant 1 : i32
318 %8 = fir.convert %c1_i32_0 : (i32) -> index
319 %9 = fir.load %arg2 : !fir.ref<i32>
320 %10 = fir.convert %9 : (i32) -> index
321 %c1_1 = arith.constant 1 : index
322 %11 = fir.convert %8 : (index) -> i32
323 %12:2 = fir.do_loop %arg5 = %8 to %10 step %c1_1 iter_args(%arg6 = %11) -> (index, i32) {
324 fir.store %arg6 to %1 : !fir.ref<i32>
325 %17 = fir.load %2 : !fir.ref<f64>
326 %18 = fir.load %1 : !fir.ref<i32>
327 %19 = fir.convert %18 : (i32) -> i64
328 %c1_i64 = arith.constant 1 : i64
329 %20 = arith.subi %19, %c1_i64 : i64
330 %21 = fir.load %0 : !fir.ref<i32>
331 %22 = fir.convert %21 : (i32) -> i64
332 %c1_i64_2 = arith.constant 1 : i64
333 %23 = arith.subi %22, %c1_i64_2 : i64
334 %24 = fir.coordinate_of %arg0, %20, %23 : (!fir.box<!fir.array<?x?xf64>>, i64, i64) -> !fir.ref<f64>
335 %25 = fir.load %24 : !fir.ref<f64>
336 %26 = arith.addf %17, %25 fastmath<contract> : f64
337 fir.store %26 to %2 : !fir.ref<f64>
338 %27 = arith.addi %arg5, %c1_1 : index
339 %28 = fir.convert %c1_1 : (index) -> i32
340 %29 = fir.load %1 : !fir.ref<i32>
341 %30 = arith.addi %29, %28 : i32
342 fir.result %27, %30 : index, i32
343 }
344 fir.store %12#1 to %1 : !fir.ref<i32>
345 %13 = arith.addi %arg3, %c1 : index
346 %14 = fir.convert %c1 : (index) -> i32
347 %15 = fir.load %0 : !fir.ref<i32>
348 %16 = arith.addi %15, %14 : i32
349 fir.result %13, %16 : index, i32
350 }
351 fir.store %7#1 to %0 : !fir.ref<i32>
352 return
353 }
355 // Note this only checks the expected transformation, not the entire generated code:
356 // CHECK-LABEL: func.func @sum2d(
357 // CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?x?xf64>> {{.*}})
358 // Only inner loop should be verisoned.
359 // CHECK: fir.do_loop
360 // CHECK: %[[ZERO:.*]] = arith.constant 0 : index
361 // CHECK: %[[DIMS0:.*]]:3 = fir.box_dims %[[ARG0]], %[[ZERO]] : {{.*}}
362 // CHECK: %[[ONE:.*]] = arith.constant 1 : index
363 // CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[ARG0]], %[[ONE]] : {{.*}}
364 // CHECK: %[[SIZE:.*]] = arith.constant 8 : index
365 // CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[DIMS0]]#2, %[[SIZE]]
366 // CHECK: %[[IF_RES:.*]]:2 = fir.if %[[CMP]] -> {{.*}}
367 // CHECK: %[[NEWARR:.*]] = fir.convert %[[ARG0]]
368 // CHECK: %[[BOXADDR:.*]] = fir.box_addr %[[NEWARR]] : {{.*}} -> !fir.ref<!fir.array<?xf64>>
369 // CHECK: %[[LOOP_RES:.*]]:2 = fir.do_loop {{.*}}
370 // Check the 2D -> 1D coordinate conversion, should have a multiply and a final add.
371 // Some other operations are checked to synch the different parts.
372 // CHECK: %[[OUTER_IDX:.*]] = arith.muli %[[DIMS1]]#2, {{.*}}
373 // CHECK: %[[INNER_IDX:.*]] = fir.convert {{.*}}
374 // CHECK: %[[ITEMSHIFT:.*]] = arith.constant 3 : index
375 // CHECK: %[[OUTER_DIV:.*]] = arith.shrsi %[[OUTER_IDX]], %[[ITEMSHIFT]]
376 // CHECK: %[[C2D:.*]] = arith.addi %[[OUTER_DIV]], %[[INNER_IDX]]
377 // CHECK: %[[COORD:.*]] = fir.coordinate_of %[[BOXADDR]], %[[C2D]] : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
378 // CHECK: %{{.*}} = fir.load %[[COORD]] : !fir.ref<f64>
379 // CHECK: fir.result %{{.*}}, %{{.*}}
380 // CHECK: }
381 // CHECK fir.result %[[LOOP_RES]]#0, %[[LOOP_RES]]#1
382 // CHECK: } else {
383 // CHECK: %[[LOOP_RES2:.*]]:2 = fir.do_loop {{.*}}
384 // CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG0]], %{{.*}} : (!fir.box<!fir.array<?x?xf64>>, i64, i64) -> !fir.ref<f64>
385 // CHECK: %{{.*}}= fir.load %[[COORD2]] : !fir.ref<f64>
386 // CHECK: fir.result %{{.*}}, %{{.*}}
387 // CHECK: }
388 // CHECK fir.result %[[LOOP_RES2]]#0, %[[LOOP_RES2]]#1
389 // CHECK: }
390 // CHECK: fir.store %[[IF_RES]]#1 to %{{.*}}
391 // CHECK: return
393 // -----
395 // subroutine sum3d(a, nx, ny, nz)
396 // real*8 :: a(:, :, :)
397 // integer :: nx, ny, nz
398 // real*8 :: sum
399 // integer :: i, j, k
400 // sum = 0
401 // do k=1,nz
402 // do j=1,ny
403 // do i=0,nx
404 // sum = sum + a(i, j, k)
405 // end do
406 // end do
407 // end do
408 // end subroutine sum3d
411 func.func @sum3d(%arg0: !fir.box<!fir.array<?x?x?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "nx"}, %arg2: !fir.ref<i32> {fir.bindc_name = "ny"}, %arg3: !fir.ref<i32> {fir.bindc_name = "nz"}) {
412 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMmoduleFsum3dEi"}
413 %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QMmoduleFsum3dEj"}
414 %2 = fir.alloca i32 {bindc_name = "k", uniq_name = "_QMmoduleFsum3dEk"}
415 %3 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QMmoduleFsum3dEsum"}
416 %cst = arith.constant 0.000000e+00 : f64
417 fir.store %cst to %3 : !fir.ref<f64>
418 %c1_i32 = arith.constant 1 : i32
419 %4 = fir.convert %c1_i32 : (i32) -> index
420 %5 = fir.load %arg3 : !fir.ref<i32>
421 %6 = fir.convert %5 : (i32) -> index
422 %c1 = arith.constant 1 : index
423 %7 = fir.convert %4 : (index) -> i32
424 %8:2 = fir.do_loop %arg4 = %4 to %6 step %c1 iter_args(%arg5 = %7) -> (index, i32) {
425 fir.store %arg5 to %2 : !fir.ref<i32>
426 %c1_i32_0 = arith.constant 1 : i32
427 %9 = fir.convert %c1_i32_0 : (i32) -> index
428 %10 = fir.load %arg2 : !fir.ref<i32>
429 %11 = fir.convert %10 : (i32) -> index
430 %c1_1 = arith.constant 1 : index
431 %12 = fir.convert %9 : (index) -> i32
432 %13:2 = fir.do_loop %arg6 = %9 to %11 step %c1_1 iter_args(%arg7 = %12) -> (index, i32) {
433 fir.store %arg7 to %1 : !fir.ref<i32>
434 %c0_i32 = arith.constant 0 : i32
435 %18 = fir.convert %c0_i32 : (i32) -> index
436 %19 = fir.load %arg1 : !fir.ref<i32>
437 %20 = fir.convert %19 : (i32) -> index
438 %c1_2 = arith.constant 1 : index
439 %21 = fir.convert %18 : (index) -> i32
440 %22:2 = fir.do_loop %arg8 = %18 to %20 step %c1_2 iter_args(%arg9 = %21) -> (index, i32) {
441 fir.store %arg9 to %0 : !fir.ref<i32>
442 %27 = fir.load %3 : !fir.ref<f64>
443 %28 = fir.load %0 : !fir.ref<i32>
444 %29 = fir.convert %28 : (i32) -> i64
445 %c1_i64 = arith.constant 1 : i64
446 %30 = arith.subi %29, %c1_i64 : i64
447 %31 = fir.load %1 : !fir.ref<i32>
448 %32 = fir.convert %31 : (i32) -> i64
449 %c1_i64_3 = arith.constant 1 : i64
450 %33 = arith.subi %32, %c1_i64_3 : i64
451 %34 = fir.load %2 : !fir.ref<i32>
452 %35 = fir.convert %34 : (i32) -> i64
453 %c1_i64_4 = arith.constant 1 : i64
454 %36 = arith.subi %35, %c1_i64_4 : i64
455 %37 = fir.coordinate_of %arg0, %30, %33, %36 : (!fir.box<!fir.array<?x?x?xf64>>, i64, i64, i64) -> !fir.ref<f64>
456 %38 = fir.load %37 : !fir.ref<f64>
457 %39 = arith.addf %27, %38 fastmath<contract> : f64
458 fir.store %39 to %3 : !fir.ref<f64>
459 %40 = arith.addi %arg8, %c1_2 : index
460 %41 = fir.convert %c1_2 : (index) -> i32
461 %42 = fir.load %0 : !fir.ref<i32>
462 %43 = arith.addi %42, %41 : i32
463 fir.result %40, %43 : index, i32
464 }
465 fir.store %22#1 to %0 : !fir.ref<i32>
466 %23 = arith.addi %arg6, %c1_1 : index
467 %24 = fir.convert %c1_1 : (index) -> i32
468 %25 = fir.load %1 : !fir.ref<i32>
469 %26 = arith.addi %25, %24 : i32
470 fir.result %23, %26 : index, i32
471 }
472 fir.store %13#1 to %1 : !fir.ref<i32>
473 %14 = arith.addi %arg4, %c1 : index
474 %15 = fir.convert %c1 : (index) -> i32
475 %16 = fir.load %2 : !fir.ref<i32>
476 %17 = arith.addi %16, %15 : i32
477 fir.result %14, %17 : index, i32
478 }
479 fir.store %8#1 to %2 : !fir.ref<i32>
480 return
481 }
483 // Note this only checks the expected transformation, not the entire generated code:
484 // CHECK-LABEL: func.func @sum3d(
485 // CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?x?x?xf64>> {{.*}})
486 // Only inner loop should be verisoned.
487 // CHECK: fir.do_loop
488 // CHECK: %[[ZERO:.*]] = arith.constant 0 : index
489 // CHECK: %[[DIMS0:.*]]:3 = fir.box_dims %[[ARG0]], %[[ZERO]] : {{.*}}
490 // CHECK: %[[ONE:.*]] = arith.constant 1 : index
491 // CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[ARG0]], %[[ONE]] : {{.*}}
492 // CHECK: %[[TWO:.*]] = arith.constant 2 : index
493 // CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[ARG0]], %[[TWO]] : {{.*}}
494 // CHECK: %[[SIZE:.*]] = arith.constant 8 : index
495 // CHECK: %[[CMP:.*]] = arith.cmpi eq, %[[DIMS0]]#2, %[[SIZE]]
496 // CHECK: %[[IF_RES:.*]]:2 = fir.if %[[CMP]] -> {{.*}}
497 // CHECK: %[[NEWARR:.*]] = fir.convert %[[ARG0]]
498 // CHECK: %[[BOXADDR:.*]] = fir.box_addr %[[NEWARR]] : {{.*}} -> !fir.ref<!fir.array<?xf64>>
499 // CHECK: %[[LOOP_RES:.*]]:2 = fir.do_loop {{.*}}
500 // Check the 3D -> 1D coordinate conversion, should have a multiply and a final add.
501 // Some other operations are checked to synch the different parts.
502 // CHECK: %[[OUTER_IDX:.*]] = arith.muli %[[DIMS2]]#2, {{.*}}
503 // CHECK: %[[MIDDLE_IDX:.*]] = arith.muli %[[DIMS1]]#2, {{.*}}
504 // CHECK: %[[MIDDLE_SUM:.*]] = arith.addi %[[MIDDLE_IDX]], %[[OUTER_IDX]]
505 // CHECK: %[[INNER_IDX:.*]] = fir.convert {{.*}}
506 // CHECK: %[[ITEMSHIFT:.*]] = arith.constant 3 : index
507 // CHECK: %[[MIDDLE_DIV:.*]] = arith.shrsi %[[MIDDLE_SUM]], %[[ITEMSHIFT]]
508 // CHECK: %[[C3D:.*]] = arith.addi %[[MIDDLE_DIV]], %[[INNER_IDX]]
509 // CHECK: %[[COORD:.*]] = fir.coordinate_of %[[BOXADDR]], %[[C3D]] : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
510 // CHECK: %{{.*}} = fir.load %[[COORD]] : !fir.ref<f64>
511 // CHECK: fir.result %{{.*}}, %{{.*}}
512 // CHECK: }
513 // CHECK fir.result %[[LOOP_RES]]#0, %[[LOOP_RES]]#1
514 // CHECK: } else {
515 // CHECK: %[[LOOP_RES2:.*]]:2 = fir.do_loop {{.*}}
516 // CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG0]], %{{.*}} : (!fir.box<!fir.array<?x?x?xf64>>, i64, i64, i64) -> !fir.ref<f64>
517 // CHECK: %{{.*}}= fir.load %[[COORD2]] : !fir.ref<f64>
518 // CHECK: fir.result %{{.*}}, %{{.*}}
519 // CHECK: }
520 // CHECK fir.result %[[LOOP_RES2]]#0, %[[LOOP_RES2]]#1
521 // CHECK: }
522 // CHECK: fir.store %[[IF_RES]]#1 to %{{.*}}
523 // CHECK: return
525 // Check that OPTIONAL argument's box is not accessed illegally
526 // before the loop.
527 func.func @test_optional_arg(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
528 %c1 = arith.constant 1 : index
529 %c20 = arith.constant 20 : index
530 %c0_i64 = arith.constant 0 : i64
531 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMcheck_modFtestEi"}
532 %1 = fir.convert %c1 : (index) -> i32
533 %2:2 = fir.do_loop %arg1 = %c1 to %c20 step %c1 iter_args(%arg2 = %1) -> (index, i32) {
534 fir.store %arg2 to %0 : !fir.ref<i32>
535 %3 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1
536 fir.if %3 {
537 %8 = fir.coordinate_of %arg0, %c0_i64 : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
538 } else {
539 }
540 %4 = arith.addi %arg1, %c1 : index
541 %5 = fir.convert %c1 : (index) -> i32
542 %6 = fir.load %0 : !fir.ref<i32>
543 %7 = arith.addi %6, %5 : i32
544 fir.result %4, %7 : index, i32
545 }
546 fir.store %2#1 to %0 : !fir.ref<i32>
547 return
548 }
549 // CHECK-LABEL: func.func @test_optional_arg(
550 // CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) {
551 // CHECK-NEXT: %[[VAL_1:.*]] = arith.constant 1 : index
552 // CHECK-NEXT: %[[VAL_2:.*]] = arith.constant 20 : index
553 // CHECK-NEXT: %[[VAL_3:.*]] = arith.constant 0 : i64
554 // CHECK-NEXT: %[[VAL_4:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMcheck_modFtestEi"}
555 // CHECK-NEXT: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (index) -> i32
556 // CHECK-NEXT: %[[VAL_6:.*]]:2 = fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] iter_args(%[[VAL_8:.*]] = %[[VAL_5]]) -> (index, i32) {
557 // CHECK-NEXT: fir.store %[[VAL_8]] to %[[VAL_4]] : !fir.ref<i32>
558 // CHECK-NEXT: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1
559 // CHECK-NEXT: fir.if %[[VAL_9]] {
560 // CHECK-NEXT: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_3]] : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
561 // CHECK-NEXT: } else {
562 // CHECK-NEXT: }
563 // CHECK-NEXT: %[[VAL_11:.*]] = arith.addi %[[VAL_7]], %[[VAL_1]] : index
564 // CHECK-NEXT: %[[VAL_12:.*]] = fir.convert %[[VAL_1]] : (index) -> i32
565 // CHECK-NEXT: %[[VAL_13:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
566 // CHECK-NEXT: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_12]] : i32
567 // CHECK-NEXT: fir.result %[[VAL_11]], %[[VAL_14]] : index, i32
568 // CHECK-NEXT: }
569 // CHECK-NEXT: fir.store %[[VAL_15:.*]]#1 to %[[VAL_4]] : !fir.ref<i32>
570 // CHECK-NEXT: return
571 // CHECK-NEXT: }
573 // test sum1d with hlfir lowering
574 func.func @_QPsum1d(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {
575 %c1 = arith.constant 1 : index
576 %cst = arith.constant 0.000000e+00 : f64
577 %0 = fir.declare %arg0 {uniq_name = "_QFsum1dEa"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
578 %1 = fir.rebox %0 : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
579 %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum1dEi"}
580 %3 = fir.declare %2 {uniq_name = "_QFsum1dEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
581 %4 = fir.declare %arg1 {uniq_name = "_QFsum1dEn"} : (!fir.ref<i32>) -> !fir.ref<i32>
582 %5 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum1dEsum"}
583 %6 = fir.declare %5 {uniq_name = "_QFsum1dEsum"} : (!fir.ref<f64>) -> !fir.ref<f64>
584 fir.store %cst to %6 : !fir.ref<f64>
585 %7 = fir.load %4 : !fir.ref<i32>
586 %8 = fir.convert %7 : (i32) -> index
587 %9 = fir.convert %c1 : (index) -> i32
588 %10:2 = fir.do_loop %arg2 = %c1 to %8 step %c1 iter_args(%arg3 = %9) -> (index, i32) {
589 fir.store %arg3 to %3 : !fir.ref<i32>
590 %11 = fir.load %6 : !fir.ref<f64>
591 %12 = fir.load %3 : !fir.ref<i32>
592 %13 = fir.convert %12 : (i32) -> i64
593 %14 = fir.array_coor %1 %13 : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64>
594 %15 = fir.load %14 : !fir.ref<f64>
595 %16 = arith.addf %11, %15 fastmath<contract> : f64
596 fir.store %16 to %6 : !fir.ref<f64>
597 %17 = arith.addi %arg2, %c1 : index
598 %18 = fir.load %3 : !fir.ref<i32>
599 %19 = arith.addi %18, %9 : i32
600 fir.result %17, %19 : index, i32
601 }
602 fir.store %10#1 to %3 : !fir.ref<i32>
603 return
604 }
605 // CHECK-LABEL: func.func @_QPsum1d(
606 // CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"},
607 // CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
608 // CHECK: %[[VAL_2:.*]] = arith.constant 1 : index
609 // CHECK: %[[VAL_3:.*]] = arith.constant 0.000000e+00 : f64
610 // CHECK: %[[VAL_4:.*]] = fir.declare %[[VAL_0]] {uniq_name = "_QFsum1dEa"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
611 // CHECK: %[[VAL_5:.*]] = fir.rebox %[[VAL_4]] : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
612 // CHECK: %[[VAL_6:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum1dEi"}
613 // CHECK: %[[VAL_7:.*]] = fir.declare %[[VAL_6]] {uniq_name = "_QFsum1dEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
614 // CHECK: %[[VAL_8:.*]] = fir.declare %[[VAL_1]] {uniq_name = "_QFsum1dEn"} : (!fir.ref<i32>) -> !fir.ref<i32>
615 // CHECK: %[[VAL_9:.*]] = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum1dEsum"}
616 // CHECK: %[[VAL_10:.*]] = fir.declare %[[VAL_9]] {uniq_name = "_QFsum1dEsum"} : (!fir.ref<f64>) -> !fir.ref<f64>
617 // CHECK: fir.store %[[VAL_3]] to %[[VAL_10]] : !fir.ref<f64>
618 // CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_8]] : !fir.ref<i32>
619 // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i32) -> index
620 // CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_2]] : (index) -> i32
621 // CHECK: %[[VAL_14:.*]] = arith.constant 0 : index
622 // CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[VAL_5]], %[[VAL_14]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)
623 // CHECK: %[[VAL_16:.*]] = arith.constant 8 : index
624 // CHECK: %[[VAL_17:.*]] = arith.cmpi eq, %[[VAL_15]]#2, %[[VAL_16]] : index
625 // CHECK: %[[VAL_18:.*]]:2 = fir.if %[[VAL_17]] -> (index, i32) {
626 // CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_5]] : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
627 // CHECK: %[[VAL_20:.*]] = fir.box_addr %[[VAL_19]] : (!fir.box<!fir.array<?xf64>>) -> !fir.ref<!fir.array<?xf64>>
628 // CHECK: %[[VAL_21:.*]]:2 = fir.do_loop %[[VAL_22:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_23:.*]] = %[[VAL_13]]) -> (index, i32) {
629 // CHECK: fir.store %[[VAL_23]] to %[[VAL_7]] : !fir.ref<i32>
630 // CHECK: %[[VAL_24:.*]] = fir.load %[[VAL_10]] : !fir.ref<f64>
631 // CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
632 // CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i32) -> i64
633 // CHECK: %[[VAL_27:.*]] = arith.constant 1 : i64
634 // CHECK: %[[VAL_28:.*]] = arith.subi %[[VAL_26]], %[[VAL_27]] : i64
635 // CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i64) -> index
636 // CHECK: %[[VAL_30:.*]] = fir.coordinate_of %[[VAL_20]], %[[VAL_29]] : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
637 // CHECK: %[[VAL_31:.*]] = fir.load %[[VAL_30]] : !fir.ref<f64>
638 // CHECK: %[[VAL_32:.*]] = arith.addf %[[VAL_24]], %[[VAL_31]] fastmath<contract> : f64
639 // CHECK: fir.store %[[VAL_32]] to %[[VAL_10]] : !fir.ref<f64>
640 // CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_22]], %[[VAL_2]] : index
641 // CHECK: %[[VAL_34:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
642 // CHECK: %[[VAL_35:.*]] = arith.addi %[[VAL_34]], %[[VAL_13]] : i32
643 // CHECK: fir.result %[[VAL_33]], %[[VAL_35]] : index, i32
644 // CHECK: }
645 // CHECK: fir.result %[[VAL_36:.*]]#0, %[[VAL_36]]#1 : index, i32
646 // CHECK: } else {
647 // CHECK: %[[VAL_37:.*]]:2 = fir.do_loop %[[VAL_38:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_39:.*]] = %[[VAL_13]]) -> (index, i32) {
648 // CHECK: fir.store %[[VAL_39]] to %[[VAL_7]] : !fir.ref<i32>
649 // CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_10]] : !fir.ref<f64>
650 // CHECK: %[[VAL_41:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
651 // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i32) -> i64
652 // CHECK: %[[VAL_43:.*]] = fir.array_coor %[[VAL_5]] %[[VAL_42]] : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64>
653 // CHECK: %[[VAL_44:.*]] = fir.load %[[VAL_43]] : !fir.ref<f64>
654 // CHECK: %[[VAL_45:.*]] = arith.addf %[[VAL_40]], %[[VAL_44]] fastmath<contract> : f64
655 // CHECK: fir.store %[[VAL_45]] to %[[VAL_10]] : !fir.ref<f64>
656 // CHECK: %[[VAL_46:.*]] = arith.addi %[[VAL_38]], %[[VAL_2]] : index
657 // CHECK: %[[VAL_47:.*]] = fir.load %[[VAL_7]] : !fir.ref<i32>
658 // CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_47]], %[[VAL_13]] : i32
659 // CHECK: fir.result %[[VAL_46]], %[[VAL_48]] : index, i32
660 // CHECK: }
661 // CHECK: fir.result %[[VAL_49:.*]]#0, %[[VAL_49]]#1 : index, i32
662 // CHECK: }
663 // CHECK: fir.store %[[VAL_50:.*]]#1 to %[[VAL_7]] : !fir.ref<i32>
664 // CHECK: return
665 // CHECK: }
667 // test sum2d with hlfir lowering
668 func.func @_QPsum2d(%arg0: !fir.box<!fir.array<?x?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "nx"}, %arg2: !fir.ref<i32> {fir.bindc_name = "ny"}) {
669 %c1 = arith.constant 1 : index
670 %cst = arith.constant 0.000000e+00 : f64
671 %0 = fir.declare %arg0 {uniq_name = "_QFsum2dEa"} : (!fir.box<!fir.array<?x?xf64>>) -> !fir.box<!fir.array<?x?xf64>>
672 %1 = fir.rebox %0 : (!fir.box<!fir.array<?x?xf64>>) -> !fir.box<!fir.array<?x?xf64>>
673 %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum2dEi"}
674 %3 = fir.declare %2 {uniq_name = "_QFsum2dEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
675 %4 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFsum2dEj"}
676 %5 = fir.declare %4 {uniq_name = "_QFsum2dEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
677 %6 = fir.declare %arg1 {uniq_name = "_QFsum2dEnx"} : (!fir.ref<i32>) -> !fir.ref<i32>
678 %7 = fir.declare %arg2 {uniq_name = "_QFsum2dEny"} : (!fir.ref<i32>) -> !fir.ref<i32>
679 %8 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum2dEsum"}
680 %9 = fir.declare %8 {uniq_name = "_QFsum2dEsum"} : (!fir.ref<f64>) -> !fir.ref<f64>
681 fir.store %cst to %9 : !fir.ref<f64>
682 %10 = fir.load %6 : !fir.ref<i32>
683 %11 = fir.convert %10 : (i32) -> index
684 %12 = fir.convert %c1 : (index) -> i32
685 %13:2 = fir.do_loop %arg3 = %c1 to %11 step %c1 iter_args(%arg4 = %12) -> (index, i32) {
686 fir.store %arg4 to %3 : !fir.ref<i32>
687 %14 = fir.load %7 : !fir.ref<i32>
688 %15 = fir.convert %14 : (i32) -> index
689 %16:2 = fir.do_loop %arg5 = %c1 to %15 step %c1 iter_args(%arg6 = %12) -> (index, i32) {
690 fir.store %arg6 to %5 : !fir.ref<i32>
691 %20 = fir.load %9 : !fir.ref<f64>
692 %21 = fir.load %5 : !fir.ref<i32>
693 %22 = fir.convert %21 : (i32) -> i64
694 %23 = fir.load %3 : !fir.ref<i32>
695 %24 = fir.convert %23 : (i32) -> i64
696 %25 = fir.array_coor %1 %22, %24 : (!fir.box<!fir.array<?x?xf64>>, i64, i64) -> !fir.ref<f64>
697 %26 = fir.load %25 : !fir.ref<f64>
698 %27 = arith.addf %20, %26 fastmath<contract> : f64
699 fir.store %27 to %9 : !fir.ref<f64>
700 %28 = arith.addi %arg5, %c1 : index
701 %29 = fir.load %5 : !fir.ref<i32>
702 %30 = arith.addi %29, %12 : i32
703 fir.result %28, %30 : index, i32
704 }
705 fir.store %16#1 to %5 : !fir.ref<i32>
706 %17 = arith.addi %arg3, %c1 : index
707 %18 = fir.load %3 : !fir.ref<i32>
708 %19 = arith.addi %18, %12 : i32
709 fir.result %17, %19 : index, i32
710 }
711 fir.store %13#1 to %3 : !fir.ref<i32>
712 return
713 }
714 // CHECK-LABEL: func.func @_QPsum2d(
715 // CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?xf64>> {fir.bindc_name = "a"},
716 // CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "nx"},
717 // CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "ny"}) {
718 // CHECK: %[[VAL_3:.*]] = arith.constant 1 : index
719 // CHECK: %[[VAL_4:.*]] = arith.constant 0.000000e+00 : f64
720 // CHECK: %[[VAL_5:.*]] = fir.declare %[[VAL_0]] {uniq_name = "_QFsum2dEa"} : (!fir.box<!fir.array<?x?xf64>>) -> !fir.box<!fir.array<?x?xf64>>
721 // CHECK: %[[VAL_6:.*]] = fir.rebox %[[VAL_5]] : (!fir.box<!fir.array<?x?xf64>>) -> !fir.box<!fir.array<?x?xf64>>
722 // CHECK: %[[VAL_7:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum2dEi"}
723 // CHECK: %[[VAL_8:.*]] = fir.declare %[[VAL_7]] {uniq_name = "_QFsum2dEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
724 // CHECK: %[[VAL_9:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFsum2dEj"}
725 // CHECK: %[[VAL_10:.*]] = fir.declare %[[VAL_9]] {uniq_name = "_QFsum2dEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
726 // CHECK: %[[VAL_11:.*]] = fir.declare %[[VAL_1]] {uniq_name = "_QFsum2dEnx"} : (!fir.ref<i32>) -> !fir.ref<i32>
727 // CHECK: %[[VAL_12:.*]] = fir.declare %[[VAL_2]] {uniq_name = "_QFsum2dEny"} : (!fir.ref<i32>) -> !fir.ref<i32>
728 // CHECK: %[[VAL_13:.*]] = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum2dEsum"}
729 // CHECK: %[[VAL_14:.*]] = fir.declare %[[VAL_13]] {uniq_name = "_QFsum2dEsum"} : (!fir.ref<f64>) -> !fir.ref<f64>
730 // CHECK: fir.store %[[VAL_4]] to %[[VAL_14]] : !fir.ref<f64>
731 // CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_11]] : !fir.ref<i32>
732 // CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i32) -> index
733 // CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_3]] : (index) -> i32
734 // CHECK: %[[VAL_18:.*]]:2 = fir.do_loop %[[VAL_19:.*]] = %[[VAL_3]] to %[[VAL_16]] step %[[VAL_3]] iter_args(%[[VAL_20:.*]] = %[[VAL_17]]) -> (index, i32) {
735 // CHECK: fir.store %[[VAL_20]] to %[[VAL_8]] : !fir.ref<i32>
736 // CHECK: %[[VAL_21:.*]] = fir.load %[[VAL_12]] : !fir.ref<i32>
737 // CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (i32) -> index
738 // CHECK: %[[VAL_23:.*]] = arith.constant 0 : index
739 // CHECK: %[[VAL_24:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_23]] : (!fir.box<!fir.array<?x?xf64>>, index) -> (index, index, index)
740 // CHECK: %[[VAL_25:.*]] = arith.constant 1 : index
741 // CHECK: %[[VAL_26:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_25]] : (!fir.box<!fir.array<?x?xf64>>, index) -> (index, index, index)
742 // CHECK: %[[VAL_27:.*]] = arith.constant 8 : index
743 // CHECK: %[[VAL_28:.*]] = arith.cmpi eq, %[[VAL_24]]#2, %[[VAL_27]] : index
744 // CHECK: %[[VAL_29:.*]]:2 = fir.if %[[VAL_28]] -> (index, i32) {
745 // CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_6]] : (!fir.box<!fir.array<?x?xf64>>) -> !fir.box<!fir.array<?xf64>>
746 // CHECK: %[[VAL_31:.*]] = fir.box_addr %[[VAL_30]] : (!fir.box<!fir.array<?xf64>>) -> !fir.ref<!fir.array<?xf64>>
747 // CHECK: %[[VAL_32:.*]]:2 = fir.do_loop %[[VAL_33:.*]] = %[[VAL_3]] to %[[VAL_22]] step %[[VAL_3]] iter_args(%[[VAL_34:.*]] = %[[VAL_17]]) -> (index, i32) {
748 // CHECK: fir.store %[[VAL_34]] to %[[VAL_10]] : !fir.ref<i32>
749 // CHECK: %[[VAL_35:.*]] = fir.load %[[VAL_14]] : !fir.ref<f64>
750 // CHECK: %[[VAL_36:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
751 // CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i32) -> i64
752 // CHECK: %[[VAL_38:.*]] = fir.load %[[VAL_8]] : !fir.ref<i32>
753 // CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_38]] : (i32) -> i64
754 // CHECK: %[[VAL_40:.*]] = arith.constant 1 : i64
755 // CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_39]], %[[VAL_40]] : i64
756 // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i64) -> index
757 // CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_26]]#2, %[[VAL_42]] : index
758 // CHECK: %[[VAL_44:.*]] = arith.constant 1 : i64
759 // CHECK: %[[VAL_45:.*]] = arith.subi %[[VAL_37]], %[[VAL_44]] : i64
760 // CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_45]] : (i64) -> index
761 // CHECK: %[[VAL_47:.*]] = arith.constant 3 : index
762 // CHECK: %[[VAL_48:.*]] = arith.shrsi %[[VAL_43]], %[[VAL_47]] : index
763 // CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_48]], %[[VAL_46]] : index
764 // CHECK: %[[VAL_50:.*]] = fir.coordinate_of %[[VAL_31]], %[[VAL_49]] : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
765 // CHECK: %[[VAL_51:.*]] = fir.load %[[VAL_50]] : !fir.ref<f64>
766 // CHECK: %[[VAL_52:.*]] = arith.addf %[[VAL_35]], %[[VAL_51]] fastmath<contract> : f64
767 // CHECK: fir.store %[[VAL_52]] to %[[VAL_14]] : !fir.ref<f64>
768 // CHECK: %[[VAL_53:.*]] = arith.addi %[[VAL_33]], %[[VAL_3]] : index
769 // CHECK: %[[VAL_54:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
770 // CHECK: %[[VAL_55:.*]] = arith.addi %[[VAL_54]], %[[VAL_17]] : i32
771 // CHECK: fir.result %[[VAL_53]], %[[VAL_55]] : index, i32
772 // CHECK: }
773 // CHECK: fir.result %[[VAL_56:.*]]#0, %[[VAL_56]]#1 : index, i32
774 // CHECK: } else {
775 // CHECK: %[[VAL_57:.*]]:2 = fir.do_loop %[[VAL_58:.*]] = %[[VAL_3]] to %[[VAL_22]] step %[[VAL_3]] iter_args(%[[VAL_59:.*]] = %[[VAL_17]]) -> (index, i32) {
776 // CHECK: fir.store %[[VAL_59]] to %[[VAL_10]] : !fir.ref<i32>
777 // CHECK: %[[VAL_60:.*]] = fir.load %[[VAL_14]] : !fir.ref<f64>
778 // CHECK: %[[VAL_61:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
779 // CHECK: %[[VAL_62:.*]] = fir.convert %[[VAL_61]] : (i32) -> i64
780 // CHECK: %[[VAL_63:.*]] = fir.load %[[VAL_8]] : !fir.ref<i32>
781 // CHECK: %[[VAL_64:.*]] = fir.convert %[[VAL_63]] : (i32) -> i64
782 // CHECK: %[[VAL_65:.*]] = fir.array_coor %[[VAL_6]] %[[VAL_62]], %[[VAL_64]] : (!fir.box<!fir.array<?x?xf64>>, i64, i64) -> !fir.ref<f64>
783 // CHECK: %[[VAL_66:.*]] = fir.load %[[VAL_65]] : !fir.ref<f64>
784 // CHECK: %[[VAL_67:.*]] = arith.addf %[[VAL_60]], %[[VAL_66]] fastmath<contract> : f64
785 // CHECK: fir.store %[[VAL_67]] to %[[VAL_14]] : !fir.ref<f64>
786 // CHECK: %[[VAL_68:.*]] = arith.addi %[[VAL_58]], %[[VAL_3]] : index
787 // CHECK: %[[VAL_69:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
788 // CHECK: %[[VAL_70:.*]] = arith.addi %[[VAL_69]], %[[VAL_17]] : i32
789 // CHECK: fir.result %[[VAL_68]], %[[VAL_70]] : index, i32
790 // CHECK: }
791 // CHECK: fir.result %[[VAL_71:.*]]#0, %[[VAL_71]]#1 : index, i32
792 // CHECK: }
793 // CHECK: fir.store %[[VAL_72:.*]]#1 to %[[VAL_10]] : !fir.ref<i32>
794 // CHECK: %[[VAL_73:.*]] = arith.addi %[[VAL_19]], %[[VAL_3]] : index
795 // CHECK: %[[VAL_74:.*]] = fir.load %[[VAL_8]] : !fir.ref<i32>
796 // CHECK: %[[VAL_75:.*]] = arith.addi %[[VAL_74]], %[[VAL_17]] : i32
797 // CHECK: fir.result %[[VAL_73]], %[[VAL_75]] : index, i32
798 // CHECK: }
799 // CHECK: fir.store %[[VAL_76:.*]]#1 to %[[VAL_8]] : !fir.ref<i32>
800 // CHECK: return
801 // CHECK: }
803 // test sum3d with hlfir lowering
804 func.func @_QPsum3d(%arg0: !fir.box<!fir.array<?x?x?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "nx"}, %arg2: !fir.ref<i32> {fir.bindc_name = "ny"}, %arg3: !fir.ref<i32> {fir.bindc_name = "nz"}) {
805 %c0 = arith.constant 0 : index
806 %c1 = arith.constant 1 : index
807 %cst = arith.constant 0.000000e+00 : f64
808 %0 = fir.declare %arg0 {uniq_name = "_QFsum3dEa"} : (!fir.box<!fir.array<?x?x?xf64>>) -> !fir.box<!fir.array<?x?x?xf64>>
809 %1 = fir.rebox %0 : (!fir.box<!fir.array<?x?x?xf64>>) -> !fir.box<!fir.array<?x?x?xf64>>
810 %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum3dEi"}
811 %3 = fir.declare %2 {uniq_name = "_QFsum3dEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
812 %4 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFsum3dEj"}
813 %5 = fir.declare %4 {uniq_name = "_QFsum3dEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
814 %6 = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFsum3dEk"}
815 %7 = fir.declare %6 {uniq_name = "_QFsum3dEk"} : (!fir.ref<i32>) -> !fir.ref<i32>
816 %8 = fir.declare %arg1 {uniq_name = "_QFsum3dEnx"} : (!fir.ref<i32>) -> !fir.ref<i32>
817 %9 = fir.declare %arg2 {uniq_name = "_QFsum3dEny"} : (!fir.ref<i32>) -> !fir.ref<i32>
818 %10 = fir.declare %arg3 {uniq_name = "_QFsum3dEnz"} : (!fir.ref<i32>) -> !fir.ref<i32>
819 %11 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum3dEsum"}
820 %12 = fir.declare %11 {uniq_name = "_QFsum3dEsum"} : (!fir.ref<f64>) -> !fir.ref<f64>
821 fir.store %cst to %12 : !fir.ref<f64>
822 %13 = fir.load %10 : !fir.ref<i32>
823 %14 = fir.convert %13 : (i32) -> index
824 %15 = fir.convert %c1 : (index) -> i32
825 %16:2 = fir.do_loop %arg4 = %c1 to %14 step %c1 iter_args(%arg5 = %15) -> (index, i32) {
826 fir.store %arg5 to %7 : !fir.ref<i32>
827 %17 = fir.load %9 : !fir.ref<i32>
828 %18 = fir.convert %17 : (i32) -> index
829 %19:2 = fir.do_loop %arg6 = %c1 to %18 step %c1 iter_args(%arg7 = %15) -> (index, i32) {
830 fir.store %arg7 to %5 : !fir.ref<i32>
831 %23 = fir.load %8 : !fir.ref<i32>
832 %24 = fir.convert %23 : (i32) -> index
833 %25 = fir.convert %c0 : (index) -> i32
834 %26:2 = fir.do_loop %arg8 = %c0 to %24 step %c1 iter_args(%arg9 = %25) -> (index, i32) {
835 fir.store %arg9 to %3 : !fir.ref<i32>
836 %30 = fir.load %12 : !fir.ref<f64>
837 %31 = fir.load %3 : !fir.ref<i32>
838 %32 = fir.convert %31 : (i32) -> i64
839 %33 = fir.load %5 : !fir.ref<i32>
840 %34 = fir.convert %33 : (i32) -> i64
841 %35 = fir.load %7 : !fir.ref<i32>
842 %36 = fir.convert %35 : (i32) -> i64
843 %37 = fir.array_coor %1 %32, %34, %36 : (!fir.box<!fir.array<?x?x?xf64>>, i64, i64, i64) -> !fir.ref<f64>
844 %38 = fir.load %37 : !fir.ref<f64>
845 %39 = arith.addf %30, %38 fastmath<contract> : f64
846 fir.store %39 to %12 : !fir.ref<f64>
847 %40 = arith.addi %arg8, %c1 : index
848 %41 = fir.load %3 : !fir.ref<i32>
849 %42 = arith.addi %41, %15 : i32
850 fir.result %40, %42 : index, i32
851 }
852 fir.store %26#1 to %3 : !fir.ref<i32>
853 %27 = arith.addi %arg6, %c1 : index
854 %28 = fir.load %5 : !fir.ref<i32>
855 %29 = arith.addi %28, %15 : i32
856 fir.result %27, %29 : index, i32
857 }
858 fir.store %19#1 to %5 : !fir.ref<i32>
859 %20 = arith.addi %arg4, %c1 : index
860 %21 = fir.load %7 : !fir.ref<i32>
861 %22 = arith.addi %21, %15 : i32
862 fir.result %20, %22 : index, i32
863 }
864 fir.store %16#1 to %7 : !fir.ref<i32>
865 return
866 }
867 // CHECK-LABEL: func.func @_QPsum3d(
868 // CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?x?xf64>> {fir.bindc_name = "a"},
869 // CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "nx"},
870 // CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "ny"},
871 // CHECK-SAME: %[[VAL_3:.*]]: !fir.ref<i32> {fir.bindc_name = "nz"}) {
872 // CHECK: %[[VAL_4:.*]] = arith.constant 0 : index
873 // CHECK: %[[VAL_5:.*]] = arith.constant 1 : index
874 // CHECK: %[[VAL_6:.*]] = arith.constant 0.000000e+00 : f64
875 // CHECK: %[[VAL_7:.*]] = fir.declare %[[VAL_0]] {uniq_name = "_QFsum3dEa"} : (!fir.box<!fir.array<?x?x?xf64>>) -> !fir.box<!fir.array<?x?x?xf64>>
876 // CHECK: %[[VAL_8:.*]] = fir.rebox %[[VAL_7]] : (!fir.box<!fir.array<?x?x?xf64>>) -> !fir.box<!fir.array<?x?x?xf64>>
877 // CHECK: %[[VAL_9:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum3dEi"}
878 // CHECK: %[[VAL_10:.*]] = fir.declare %[[VAL_9]] {uniq_name = "_QFsum3dEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
879 // CHECK: %[[VAL_11:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFsum3dEj"}
880 // CHECK: %[[VAL_12:.*]] = fir.declare %[[VAL_11]] {uniq_name = "_QFsum3dEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
881 // CHECK: %[[VAL_13:.*]] = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFsum3dEk"}
882 // CHECK: %[[VAL_14:.*]] = fir.declare %[[VAL_13]] {uniq_name = "_QFsum3dEk"} : (!fir.ref<i32>) -> !fir.ref<i32>
883 // CHECK: %[[VAL_15:.*]] = fir.declare %[[VAL_1]] {uniq_name = "_QFsum3dEnx"} : (!fir.ref<i32>) -> !fir.ref<i32>
884 // CHECK: %[[VAL_16:.*]] = fir.declare %[[VAL_2]] {uniq_name = "_QFsum3dEny"} : (!fir.ref<i32>) -> !fir.ref<i32>
885 // CHECK: %[[VAL_17:.*]] = fir.declare %[[VAL_3]] {uniq_name = "_QFsum3dEnz"} : (!fir.ref<i32>) -> !fir.ref<i32>
886 // CHECK: %[[VAL_18:.*]] = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum3dEsum"}
887 // CHECK: %[[VAL_19:.*]] = fir.declare %[[VAL_18]] {uniq_name = "_QFsum3dEsum"} : (!fir.ref<f64>) -> !fir.ref<f64>
888 // CHECK: fir.store %[[VAL_6]] to %[[VAL_19]] : !fir.ref<f64>
889 // CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_17]] : !fir.ref<i32>
890 // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index
891 // CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_5]] : (index) -> i32
892 // CHECK: %[[VAL_23:.*]]:2 = fir.do_loop %[[VAL_24:.*]] = %[[VAL_5]] to %[[VAL_21]] step %[[VAL_5]] iter_args(%[[VAL_25:.*]] = %[[VAL_22]]) -> (index, i32) {
893 // CHECK: fir.store %[[VAL_25]] to %[[VAL_14]] : !fir.ref<i32>
894 // CHECK: %[[VAL_26:.*]] = fir.load %[[VAL_16]] : !fir.ref<i32>
895 // CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i32) -> index
896 // CHECK: %[[VAL_28:.*]]:2 = fir.do_loop %[[VAL_29:.*]] = %[[VAL_5]] to %[[VAL_27]] step %[[VAL_5]] iter_args(%[[VAL_30:.*]] = %[[VAL_22]]) -> (index, i32) {
897 // CHECK: fir.store %[[VAL_30]] to %[[VAL_12]] : !fir.ref<i32>
898 // CHECK: %[[VAL_31:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32>
899 // CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i32) -> index
900 // CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_4]] : (index) -> i32
901 // CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
902 // CHECK: %[[VAL_35:.*]]:3 = fir.box_dims %[[VAL_8]], %[[VAL_34]] : (!fir.box<!fir.array<?x?x?xf64>>, index) -> (index, index, index)
903 // CHECK: %[[VAL_36:.*]] = arith.constant 1 : index
904 // CHECK: %[[VAL_37:.*]]:3 = fir.box_dims %[[VAL_8]], %[[VAL_36]] : (!fir.box<!fir.array<?x?x?xf64>>, index) -> (index, index, index)
905 // CHECK: %[[VAL_38:.*]] = arith.constant 2 : index
906 // CHECK: %[[VAL_39:.*]]:3 = fir.box_dims %[[VAL_8]], %[[VAL_38]] : (!fir.box<!fir.array<?x?x?xf64>>, index) -> (index, index, index)
907 // CHECK: %[[VAL_40:.*]] = arith.constant 8 : index
908 // CHECK: %[[VAL_41:.*]] = arith.cmpi eq, %[[VAL_35]]#2, %[[VAL_40]] : index
909 // CHECK: %[[VAL_42:.*]]:2 = fir.if %[[VAL_41]] -> (index, i32) {
910 // CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_8]] : (!fir.box<!fir.array<?x?x?xf64>>) -> !fir.box<!fir.array<?xf64>>
911 // CHECK: %[[VAL_44:.*]] = fir.box_addr %[[VAL_43]] : (!fir.box<!fir.array<?xf64>>) -> !fir.ref<!fir.array<?xf64>>
912 // CHECK: %[[VAL_45:.*]]:2 = fir.do_loop %[[VAL_46:.*]] = %[[VAL_4]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_47:.*]] = %[[VAL_33]]) -> (index, i32) {
913 // CHECK: fir.store %[[VAL_47]] to %[[VAL_10]] : !fir.ref<i32>
914 // CHECK: %[[VAL_48:.*]] = fir.load %[[VAL_19]] : !fir.ref<f64>
915 // CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
916 // CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i32) -> i64
917 // CHECK: %[[VAL_51:.*]] = fir.load %[[VAL_12]] : !fir.ref<i32>
918 // CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_51]] : (i32) -> i64
919 // CHECK: %[[VAL_53:.*]] = fir.load %[[VAL_14]] : !fir.ref<i32>
920 // CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (i32) -> i64
921 // CHECK: %[[VAL_55:.*]] = arith.constant 1 : i64
922 // CHECK: %[[VAL_56:.*]] = arith.subi %[[VAL_54]], %[[VAL_55]] : i64
923 // CHECK: %[[VAL_57:.*]] = fir.convert %[[VAL_56]] : (i64) -> index
924 // CHECK: %[[VAL_58:.*]] = arith.muli %[[VAL_39]]#2, %[[VAL_57]] : index
925 // CHECK: %[[VAL_59:.*]] = arith.constant 1 : i64
926 // CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_52]], %[[VAL_59]] : i64
927 // CHECK: %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (i64) -> index
928 // CHECK: %[[VAL_62:.*]] = arith.muli %[[VAL_37]]#2, %[[VAL_61]] : index
929 // CHECK: %[[VAL_63:.*]] = arith.addi %[[VAL_62]], %[[VAL_58]] : index
930 // CHECK: %[[VAL_64:.*]] = arith.constant 1 : i64
931 // CHECK: %[[VAL_65:.*]] = arith.subi %[[VAL_50]], %[[VAL_64]] : i64
932 // CHECK: %[[VAL_66:.*]] = fir.convert %[[VAL_65]] : (i64) -> index
933 // CHECK: %[[VAL_67:.*]] = arith.constant 3 : index
934 // CHECK: %[[VAL_68:.*]] = arith.shrsi %[[VAL_63]], %[[VAL_67]] : index
935 // CHECK: %[[VAL_69:.*]] = arith.addi %[[VAL_68]], %[[VAL_66]] : index
936 // CHECK: %[[VAL_70:.*]] = fir.coordinate_of %[[VAL_44]], %[[VAL_69]] : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
937 // CHECK: %[[VAL_71:.*]] = fir.load %[[VAL_70]] : !fir.ref<f64>
938 // CHECK: %[[VAL_72:.*]] = arith.addf %[[VAL_48]], %[[VAL_71]] fastmath<contract> : f64
939 // CHECK: fir.store %[[VAL_72]] to %[[VAL_19]] : !fir.ref<f64>
940 // CHECK: %[[VAL_73:.*]] = arith.addi %[[VAL_46]], %[[VAL_5]] : index
941 // CHECK: %[[VAL_74:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
942 // CHECK: %[[VAL_75:.*]] = arith.addi %[[VAL_74]], %[[VAL_22]] : i32
943 // CHECK: fir.result %[[VAL_73]], %[[VAL_75]] : index, i32
944 // CHECK: }
945 // CHECK: fir.result %[[VAL_76:.*]]#0, %[[VAL_76]]#1 : index, i32
946 // CHECK: } else {
947 // CHECK: %[[VAL_77:.*]]:2 = fir.do_loop %[[VAL_78:.*]] = %[[VAL_4]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_79:.*]] = %[[VAL_33]]) -> (index, i32) {
948 // CHECK: fir.store %[[VAL_79]] to %[[VAL_10]] : !fir.ref<i32>
949 // CHECK: %[[VAL_80:.*]] = fir.load %[[VAL_19]] : !fir.ref<f64>
950 // CHECK: %[[VAL_81:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
951 // CHECK: %[[VAL_82:.*]] = fir.convert %[[VAL_81]] : (i32) -> i64
952 // CHECK: %[[VAL_83:.*]] = fir.load %[[VAL_12]] : !fir.ref<i32>
953 // CHECK: %[[VAL_84:.*]] = fir.convert %[[VAL_83]] : (i32) -> i64
954 // CHECK: %[[VAL_85:.*]] = fir.load %[[VAL_14]] : !fir.ref<i32>
955 // CHECK: %[[VAL_86:.*]] = fir.convert %[[VAL_85]] : (i32) -> i64
956 // CHECK: %[[VAL_87:.*]] = fir.array_coor %[[VAL_8]] %[[VAL_82]], %[[VAL_84]], %[[VAL_86]] : (!fir.box<!fir.array<?x?x?xf64>>, i64, i64, i64) -> !fir.ref<f64>
957 // CHECK: %[[VAL_88:.*]] = fir.load %[[VAL_87]] : !fir.ref<f64>
958 // CHECK: %[[VAL_89:.*]] = arith.addf %[[VAL_80]], %[[VAL_88]] fastmath<contract> : f64
959 // CHECK: fir.store %[[VAL_89]] to %[[VAL_19]] : !fir.ref<f64>
960 // CHECK: %[[VAL_90:.*]] = arith.addi %[[VAL_78]], %[[VAL_5]] : index
961 // CHECK: %[[VAL_91:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
962 // CHECK: %[[VAL_92:.*]] = arith.addi %[[VAL_91]], %[[VAL_22]] : i32
963 // CHECK: fir.result %[[VAL_90]], %[[VAL_92]] : index, i32
964 // CHECK: }
965 // CHECK: fir.result %[[VAL_93:.*]]#0, %[[VAL_93]]#1 : index, i32
966 // CHECK: }
967 // CHECK: fir.store %[[VAL_94:.*]]#1 to %[[VAL_10]] : !fir.ref<i32>
968 // CHECK: %[[VAL_95:.*]] = arith.addi %[[VAL_29]], %[[VAL_5]] : index
969 // CHECK: %[[VAL_96:.*]] = fir.load %[[VAL_12]] : !fir.ref<i32>
970 // CHECK: %[[VAL_97:.*]] = arith.addi %[[VAL_96]], %[[VAL_22]] : i32
971 // CHECK: fir.result %[[VAL_95]], %[[VAL_97]] : index, i32
972 // CHECK: }
973 // CHECK: fir.store %[[VAL_98:.*]]#1 to %[[VAL_12]] : !fir.ref<i32>
974 // CHECK: %[[VAL_99:.*]] = arith.addi %[[VAL_24]], %[[VAL_5]] : index
975 // CHECK: %[[VAL_100:.*]] = fir.load %[[VAL_14]] : !fir.ref<i32>
976 // CHECK: %[[VAL_101:.*]] = arith.addi %[[VAL_100]], %[[VAL_22]] : i32
977 // CHECK: fir.result %[[VAL_99]], %[[VAL_101]] : index, i32
978 // CHECK: }
979 // CHECK: fir.store %[[VAL_102:.*]]#1 to %[[VAL_14]] : !fir.ref<i32>
980 // CHECK: return
981 // CHECK: }
983 // test non-default lower bounds are handled correctly
984 func.func @_QPlbounds_repro(%arg0: !fir.box<!fir.array<?x?x?xf32>> {fir.bindc_name = "u"}, %arg1: !fir.ref<i32> {fir.bindc_name = "ims"}, %arg2: !fir.ref<i32> {fir.bindc_name = "jms"}, %arg3: !fir.ref<i32> {fir.bindc_name = "kms"}, %arg4: !fir.ref<i32> {fir.bindc_name = "ips"}, %arg5: !fir.ref<i32> {fir.bindc_name = "ipe"}, %arg6: !fir.ref<i32> {fir.bindc_name = "jps"}, %arg7: !fir.ref<i32> {fir.bindc_name = "jpe"}, %arg8: !fir.ref<i32> {fir.bindc_name = "kps"}, %arg9: !fir.ref<i32> {fir.bindc_name = "kpe"}) {
985 %c1_i32 = arith.constant 1 : i32
986 %c1 = arith.constant 1 : index
987 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFlbounds_reproEi"}
988 %1 = fir.declare %0 {uniq_name = "_QFlbounds_reproEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
989 %2 = fir.declare %arg1 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEims"} : (!fir.ref<i32>) -> !fir.ref<i32>
990 %3 = fir.declare %arg5 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEipe"} : (!fir.ref<i32>) -> !fir.ref<i32>
991 %4 = fir.declare %arg4 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEips"} : (!fir.ref<i32>) -> !fir.ref<i32>
992 %5 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFlbounds_reproEj"}
993 %6 = fir.declare %5 {uniq_name = "_QFlbounds_reproEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
994 %7 = fir.declare %arg2 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEjms"} : (!fir.ref<i32>) -> !fir.ref<i32>
995 %8 = fir.declare %arg7 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEjpe"} : (!fir.ref<i32>) -> !fir.ref<i32>
996 %9 = fir.declare %arg6 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEjps"} : (!fir.ref<i32>) -> !fir.ref<i32>
997 %10 = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFlbounds_reproEk"}
998 %11 = fir.declare %10 {uniq_name = "_QFlbounds_reproEk"} : (!fir.ref<i32>) -> !fir.ref<i32>
999 %12 = fir.declare %arg3 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEkms"} : (!fir.ref<i32>) -> !fir.ref<i32>
1000 %13 = fir.declare %arg9 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEkpe"} : (!fir.ref<i32>) -> !fir.ref<i32>
1001 %14 = fir.declare %arg8 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEkps"} : (!fir.ref<i32>) -> !fir.ref<i32>
1002 %15 = fir.alloca f32 {bindc_name = "vmax", uniq_name = "_QFlbounds_reproEvmax"}
1003 %16 = fir.declare %15 {uniq_name = "_QFlbounds_reproEvmax"} : (!fir.ref<f32>) -> !fir.ref<f32>
1004 %17 = fir.load %12 : !fir.ref<i32>
1005 %18 = fir.convert %17 : (i32) -> index
1006 %19 = fir.load %2 : !fir.ref<i32>
1007 %20 = fir.convert %19 : (i32) -> index
1008 %21 = fir.load %7 : !fir.ref<i32>
1009 %22 = fir.convert %21 : (i32) -> index
1010 %23 = fir.shift %18, %20, %22 : (index, index, index) -> !fir.shift<3>
1011 %24 = fir.declare %arg0(%23) {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFlbounds_reproEu"} : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>) -> !fir.box<!fir.array<?x?x?xf32>>
1012 %25 = fir.rebox %24(%23) : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>) -> !fir.box<!fir.array<?x?x?xf32>>
1013 %26 = fir.array_coor %25(%23) %c1, %c1, %c1 : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>, index, index, index) -> !fir.ref<f32>
1014 %27 = fir.load %26 : !fir.ref<f32>
1015 fir.store %27 to %16 : !fir.ref<f32>
1016 %28 = fir.load %9 : !fir.ref<i32>
1017 %29 = fir.convert %28 : (i32) -> index
1018 %30 = fir.load %8 : !fir.ref<i32>
1019 %31 = arith.subi %30, %c1_i32 : i32
1020 %32 = fir.convert %31 : (i32) -> index
1021 %33 = fir.convert %29 : (index) -> i32
1022 %34:2 = fir.do_loop %arg10 = %29 to %32 step %c1 iter_args(%arg11 = %33) -> (index, i32) {
1023 fir.store %arg11 to %6 : !fir.ref<i32>
1024 %35 = fir.load %4 : !fir.ref<i32>
1025 %36 = fir.convert %35 : (i32) -> index
1026 %37 = fir.load %3 : !fir.ref<i32>
1027 %38 = fir.convert %37 : (i32) -> index
1028 %39 = fir.convert %36 : (index) -> i32
1029 %40:2 = fir.do_loop %arg12 = %36 to %38 step %c1 iter_args(%arg13 = %39) -> (index, i32) {
1030 fir.store %arg13 to %1 : !fir.ref<i32>
1031 %45 = fir.load %14 : !fir.ref<i32>
1032 %46 = fir.convert %45 : (i32) -> index
1033 %47 = fir.load %13 : !fir.ref<i32>
1034 %48 = arith.subi %47, %c1_i32 : i32
1035 %49 = fir.convert %48 : (i32) -> index
1036 %50 = fir.convert %46 : (index) -> i32
1037 %51:2 = fir.do_loop %arg14 = %46 to %49 step %c1 iter_args(%arg15 = %50) -> (index, i32) {
1038 fir.store %arg15 to %11 : !fir.ref<i32>
1039 %56 = fir.load %11 : !fir.ref<i32>
1040 %57 = fir.convert %56 : (i32) -> i64
1041 %58 = fir.load %1 : !fir.ref<i32>
1042 %59 = fir.convert %58 : (i32) -> i64
1043 %60 = fir.load %6 : !fir.ref<i32>
1044 %61 = fir.convert %60 : (i32) -> i64
1045 %62 = fir.array_coor %25(%23) %57, %59, %61 : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>, i64, i64, i64) -> !fir.ref<f32>
1046 %63 = fir.load %62 : !fir.ref<f32>
1047 %64 = fir.load %16 : !fir.ref<f32>
1048 %65 = arith.cmpf ogt, %63, %64 : f32
1049 fir.if %65 {
1050 %70 = fir.load %11 : !fir.ref<i32>
1051 %71 = fir.convert %70 : (i32) -> i64
1052 %72 = fir.load %1 : !fir.ref<i32>
1053 %73 = fir.convert %72 : (i32) -> i64
1054 %74 = fir.load %6 : !fir.ref<i32>
1055 %75 = fir.convert %74 : (i32) -> i64
1056 %76 = fir.array_coor %25(%23) %71, %73, %75 : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>, i64, i64, i64) -> !fir.ref<f32>
1057 %77 = fir.load %76 : !fir.ref<f32>
1058 fir.store %77 to %16 : !fir.ref<f32>
1059 } else {
1060 }
1061 %66 = arith.addi %arg14, %c1 : index
1062 %67 = fir.convert %c1 : (index) -> i32
1063 %68 = fir.load %11 : !fir.ref<i32>
1064 %69 = arith.addi %68, %67 : i32
1065 fir.result %66, %69 : index, i32
1066 }
1067 fir.store %51#1 to %11 : !fir.ref<i32>
1068 %52 = arith.addi %arg12, %c1 : index
1069 %53 = fir.convert %c1 : (index) -> i32
1070 %54 = fir.load %1 : !fir.ref<i32>
1071 %55 = arith.addi %54, %53 : i32
1072 fir.result %52, %55 : index, i32
1073 }
1074 fir.store %40#1 to %1 : !fir.ref<i32>
1075 %41 = arith.addi %arg10, %c1 : index
1076 %42 = fir.convert %c1 : (index) -> i32
1077 %43 = fir.load %6 : !fir.ref<i32>
1078 %44 = arith.addi %43, %42 : i32
1079 fir.result %41, %44 : index, i32
1080 }
1081 fir.store %34#1 to %6 : !fir.ref<i32>
1082 return
1083 }
1084 // CHECK-LABEL: func.func @_QPlbounds_repro(
1085 // CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?x?xf32>> {fir.bindc_name = "u"},
1086 // CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "ims"},
1087 // CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "jms"},
1088 // CHECK-SAME: %[[VAL_3:.*]]: !fir.ref<i32> {fir.bindc_name = "kms"},
1089 // CHECK-SAME: %[[VAL_4:.*]]: !fir.ref<i32> {fir.bindc_name = "ips"},
1090 // CHECK-SAME: %[[VAL_5:.*]]: !fir.ref<i32> {fir.bindc_name = "ipe"},
1091 // CHECK-SAME: %[[VAL_6:.*]]: !fir.ref<i32> {fir.bindc_name = "jps"},
1092 // CHECK-SAME: %[[VAL_7:.*]]: !fir.ref<i32> {fir.bindc_name = "jpe"},
1093 // CHECK-SAME: %[[VAL_8:.*]]: !fir.ref<i32> {fir.bindc_name = "kps"},
1094 // CHECK-SAME: %[[VAL_9:.*]]: !fir.ref<i32> {fir.bindc_name = "kpe"}) {
1095 // CHECK: %[[VAL_10:.*]] = arith.constant 1 : i32
1096 // CHECK: %[[VAL_11:.*]] = arith.constant 1 : index
1097 // CHECK: %[[VAL_12:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFlbounds_reproEi"}
1098 // CHECK: %[[VAL_13:.*]] = fir.declare %[[VAL_12]] {uniq_name = "_QFlbounds_reproEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1099 // CHECK: %[[VAL_14:.*]] = fir.declare %[[VAL_1]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEims"} : (!fir.ref<i32>) -> !fir.ref<i32>
1100 // CHECK: %[[VAL_15:.*]] = fir.declare %[[VAL_5]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEipe"} : (!fir.ref<i32>) -> !fir.ref<i32>
1101 // CHECK: %[[VAL_16:.*]] = fir.declare %[[VAL_4]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEips"} : (!fir.ref<i32>) -> !fir.ref<i32>
1102 // CHECK: %[[VAL_17:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFlbounds_reproEj"}
1103 // CHECK: %[[VAL_18:.*]] = fir.declare %[[VAL_17]] {uniq_name = "_QFlbounds_reproEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
1104 // CHECK: %[[VAL_19:.*]] = fir.declare %[[VAL_2]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEjms"} : (!fir.ref<i32>) -> !fir.ref<i32>
1105 // CHECK: %[[VAL_20:.*]] = fir.declare %[[VAL_7]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEjpe"} : (!fir.ref<i32>) -> !fir.ref<i32>
1106 // CHECK: %[[VAL_21:.*]] = fir.declare %[[VAL_6]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEjps"} : (!fir.ref<i32>) -> !fir.ref<i32>
1107 // CHECK: %[[VAL_22:.*]] = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFlbounds_reproEk"}
1108 // CHECK: %[[VAL_23:.*]] = fir.declare %[[VAL_22]] {uniq_name = "_QFlbounds_reproEk"} : (!fir.ref<i32>) -> !fir.ref<i32>
1109 // CHECK: %[[VAL_24:.*]] = fir.declare %[[VAL_3]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEkms"} : (!fir.ref<i32>) -> !fir.ref<i32>
1110 // CHECK: %[[VAL_25:.*]] = fir.declare %[[VAL_9]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEkpe"} : (!fir.ref<i32>) -> !fir.ref<i32>
1111 // CHECK: %[[VAL_26:.*]] = fir.declare %[[VAL_8]] {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEkps"} : (!fir.ref<i32>) -> !fir.ref<i32>
1112 // CHECK: %[[VAL_27:.*]] = fir.alloca f32 {bindc_name = "vmax", uniq_name = "_QFlbounds_reproEvmax"}
1113 // CHECK: %[[VAL_28:.*]] = fir.declare %[[VAL_27]] {uniq_name = "_QFlbounds_reproEvmax"} : (!fir.ref<f32>) -> !fir.ref<f32>
1114 // CHECK: %[[VAL_29:.*]] = fir.load %[[VAL_24]] : !fir.ref<i32>
1115 // CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i32) -> index
1116 // CHECK: %[[VAL_31:.*]] = fir.load %[[VAL_14]] : !fir.ref<i32>
1117 // CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i32) -> index
1118 // CHECK: %[[VAL_33:.*]] = fir.load %[[VAL_19]] : !fir.ref<i32>
1119 // CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i32) -> index
1120 // CHECK: %[[VAL_35:.*]] = fir.shift %[[VAL_30]], %[[VAL_32]], %[[VAL_34]] : (index, index, index) -> !fir.shift<3>
1121 // CHECK: %[[VAL_36:.*]] = fir.declare %[[VAL_0]](%[[VAL_35]]) {fortran_attrs = {{.*}}, uniq_name = "_QFlbounds_reproEu"} : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>) -> !fir.box<!fir.array<?x?x?xf32>>
1122 // CHECK: %[[VAL_37:.*]] = fir.rebox %[[VAL_36]](%[[VAL_35]]) : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>) -> !fir.box<!fir.array<?x?x?xf32>>
1123 // CHECK: %[[VAL_38:.*]] = fir.array_coor %[[VAL_37]](%[[VAL_35]]) %[[VAL_11]], %[[VAL_11]], %[[VAL_11]] : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>, index, index, index) -> !fir.ref<f32>
1124 // CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_38]] : !fir.ref<f32>
1125 // CHECK: fir.store %[[VAL_39]] to %[[VAL_28]] : !fir.ref<f32>
1126 // CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_21]] : !fir.ref<i32>
1127 // CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i32) -> index
1128 // CHECK: %[[VAL_42:.*]] = fir.load %[[VAL_20]] : !fir.ref<i32>
1129 // CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_10]] : i32
1130 // CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_43]] : (i32) -> index
1131 // CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_41]] : (index) -> i32
1132 // CHECK: %[[VAL_46:.*]]:2 = fir.do_loop %[[VAL_47:.*]] = %[[VAL_41]] to %[[VAL_44]] step %[[VAL_11]] iter_args(%[[VAL_48:.*]] = %[[VAL_45]]) -> (index, i32) {
1133 // CHECK: fir.store %[[VAL_48]] to %[[VAL_18]] : !fir.ref<i32>
1134 // CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_16]] : !fir.ref<i32>
1135 // CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i32) -> index
1136 // CHECK: %[[VAL_51:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32>
1137 // CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_51]] : (i32) -> index
1138 // CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_50]] : (index) -> i32
1139 // CHECK: %[[VAL_54:.*]]:2 = fir.do_loop %[[VAL_55:.*]] = %[[VAL_50]] to %[[VAL_52]] step %[[VAL_11]] iter_args(%[[VAL_56:.*]] = %[[VAL_53]]) -> (index, i32) {
1140 // CHECK: fir.store %[[VAL_56]] to %[[VAL_13]] : !fir.ref<i32>
1141 // CHECK: %[[VAL_57:.*]] = fir.load %[[VAL_26]] : !fir.ref<i32>
1142 // CHECK: %[[VAL_58:.*]] = fir.convert %[[VAL_57]] : (i32) -> index
1143 // CHECK: %[[VAL_59:.*]] = fir.load %[[VAL_25]] : !fir.ref<i32>
1144 // CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_59]], %[[VAL_10]] : i32
1145 // CHECK: %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (i32) -> index
1146 // CHECK: %[[VAL_62:.*]] = fir.convert %[[VAL_58]] : (index) -> i32
1147 // CHECK: %[[VAL_63:.*]] = arith.constant 0 : index
1148 // CHECK: %[[VAL_64:.*]]:3 = fir.box_dims %[[VAL_37]], %[[VAL_63]] : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index)
1149 // CHECK: %[[VAL_65:.*]] = arith.constant 1 : index
1150 // CHECK: %[[VAL_66:.*]]:3 = fir.box_dims %[[VAL_37]], %[[VAL_65]] : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index)
1151 // CHECK: %[[VAL_67:.*]] = arith.constant 2 : index
1152 // CHECK: %[[VAL_68:.*]]:3 = fir.box_dims %[[VAL_37]], %[[VAL_67]] : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index)
1153 // CHECK: %[[VAL_69:.*]] = arith.constant 4 : index
1154 // CHECK: %[[VAL_70:.*]] = arith.cmpi eq, %[[VAL_64]]#2, %[[VAL_69]] : index
1155 // CHECK: %[[VAL_71:.*]]:2 = fir.if %[[VAL_70]] -> (index, i32) {
1156 // CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_37]] : (!fir.box<!fir.array<?x?x?xf32>>) -> !fir.box<!fir.array<?xf32>>
1157 // CHECK: %[[VAL_73:.*]] = fir.box_addr %[[VAL_72]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
1158 // CHECK: %[[VAL_74:.*]]:2 = fir.do_loop %[[VAL_75:.*]] = %[[VAL_58]] to %[[VAL_61]] step %[[VAL_11]] iter_args(%[[VAL_76:.*]] = %[[VAL_62]]) -> (index, i32) {
1159 // CHECK: fir.store %[[VAL_76]] to %[[VAL_23]] : !fir.ref<i32>
1160 // CHECK: %[[VAL_77:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
1161 // CHECK: %[[VAL_78:.*]] = fir.convert %[[VAL_77]] : (i32) -> i64
1162 // CHECK: %[[VAL_79:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
1163 // CHECK: %[[VAL_80:.*]] = fir.convert %[[VAL_79]] : (i32) -> i64
1164 // CHECK: %[[VAL_81:.*]] = fir.load %[[VAL_18]] : !fir.ref<i32>
1165 // CHECK: %[[VAL_82:.*]] = fir.convert %[[VAL_81]] : (i32) -> i64
1166 // CHECK: %[[VAL_83:.*]] = fir.convert %[[VAL_34]] : (index) -> i64
1167 // CHECK: %[[VAL_84:.*]] = arith.subi %[[VAL_82]], %[[VAL_83]] : i64
1168 // CHECK: %[[VAL_85:.*]] = fir.convert %[[VAL_84]] : (i64) -> index
1169 // CHECK: %[[VAL_86:.*]] = arith.muli %[[VAL_68]]#2, %[[VAL_85]] : index
1170 // CHECK: %[[VAL_87:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
1171 // CHECK: %[[VAL_88:.*]] = arith.subi %[[VAL_80]], %[[VAL_87]] : i64
1172 // CHECK: %[[VAL_89:.*]] = fir.convert %[[VAL_88]] : (i64) -> index
1173 // CHECK: %[[VAL_90:.*]] = arith.muli %[[VAL_66]]#2, %[[VAL_89]] : index
1174 // CHECK: %[[VAL_91:.*]] = arith.addi %[[VAL_90]], %[[VAL_86]] : index
1175 // CHECK: %[[VAL_92:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
1176 // CHECK: %[[VAL_93:.*]] = arith.subi %[[VAL_78]], %[[VAL_92]] : i64
1177 // CHECK: %[[VAL_94:.*]] = fir.convert %[[VAL_93]] : (i64) -> index
1178 // CHECK: %[[VAL_95:.*]] = arith.constant 2 : index
1179 // CHECK: %[[VAL_96:.*]] = arith.shrsi %[[VAL_91]], %[[VAL_95]] : index
1180 // CHECK: %[[VAL_97:.*]] = arith.addi %[[VAL_96]], %[[VAL_94]] : index
1181 // CHECK: %[[VAL_98:.*]] = fir.coordinate_of %[[VAL_73]], %[[VAL_97]] : (!fir.ref<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1182 // CHECK: %[[VAL_99:.*]] = fir.load %[[VAL_98]] : !fir.ref<f32>
1183 // CHECK: %[[VAL_100:.*]] = fir.load %[[VAL_28]] : !fir.ref<f32>
1184 // CHECK: %[[VAL_101:.*]] = arith.cmpf ogt, %[[VAL_99]], %[[VAL_100]] : f32
1185 // CHECK: fir.if %[[VAL_101]] {
1186 // CHECK: %[[VAL_102:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
1187 // CHECK: %[[VAL_103:.*]] = fir.convert %[[VAL_102]] : (i32) -> i64
1188 // CHECK: %[[VAL_104:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
1189 // CHECK: %[[VAL_105:.*]] = fir.convert %[[VAL_104]] : (i32) -> i64
1190 // CHECK: %[[VAL_106:.*]] = fir.load %[[VAL_18]] : !fir.ref<i32>
1191 // CHECK: %[[VAL_107:.*]] = fir.convert %[[VAL_106]] : (i32) -> i64
1192 // CHECK: %[[VAL_108:.*]] = fir.convert %[[VAL_34]] : (index) -> i64
1193 // CHECK: %[[VAL_109:.*]] = arith.subi %[[VAL_107]], %[[VAL_108]] : i64
1194 // CHECK: %[[VAL_110:.*]] = fir.convert %[[VAL_109]] : (i64) -> index
1195 // CHECK: %[[VAL_111:.*]] = arith.muli %[[VAL_68]]#2, %[[VAL_110]] : index
1196 // CHECK: %[[VAL_112:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
1197 // CHECK: %[[VAL_113:.*]] = arith.subi %[[VAL_105]], %[[VAL_112]] : i64
1198 // CHECK: %[[VAL_114:.*]] = fir.convert %[[VAL_113]] : (i64) -> index
1199 // CHECK: %[[VAL_115:.*]] = arith.muli %[[VAL_66]]#2, %[[VAL_114]] : index
1200 // CHECK: %[[VAL_116:.*]] = arith.addi %[[VAL_115]], %[[VAL_111]] : index
1201 // CHECK: %[[VAL_117:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
1202 // CHECK: %[[VAL_118:.*]] = arith.subi %[[VAL_103]], %[[VAL_117]] : i64
1203 // CHECK: %[[VAL_119:.*]] = fir.convert %[[VAL_118]] : (i64) -> index
1204 // CHECK: %[[VAL_120:.*]] = arith.constant 2 : index
1205 // CHECK: %[[VAL_121:.*]] = arith.shrsi %[[VAL_116]], %[[VAL_120]] : index
1206 // CHECK: %[[VAL_122:.*]] = arith.addi %[[VAL_121]], %[[VAL_119]] : index
1207 // CHECK: %[[VAL_123:.*]] = fir.coordinate_of %[[VAL_73]], %[[VAL_122]] : (!fir.ref<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1208 // CHECK: %[[VAL_124:.*]] = fir.load %[[VAL_123]] : !fir.ref<f32>
1209 // CHECK: fir.store %[[VAL_124]] to %[[VAL_28]] : !fir.ref<f32>
1210 // CHECK: } else {
1211 // CHECK: }
1212 // CHECK: %[[VAL_125:.*]] = arith.addi %[[VAL_75]], %[[VAL_11]] : index
1213 // CHECK: %[[VAL_126:.*]] = fir.convert %[[VAL_11]] : (index) -> i32
1214 // CHECK: %[[VAL_127:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
1215 // CHECK: %[[VAL_128:.*]] = arith.addi %[[VAL_127]], %[[VAL_126]] : i32
1216 // CHECK: fir.result %[[VAL_125]], %[[VAL_128]] : index, i32
1217 // CHECK: }
1218 // CHECK: fir.result %[[VAL_129:.*]]#0, %[[VAL_129]]#1 : index, i32
1219 // CHECK: } else {
1220 // CHECK: %[[VAL_130:.*]]:2 = fir.do_loop %[[VAL_131:.*]] = %[[VAL_58]] to %[[VAL_61]] step %[[VAL_11]] iter_args(%[[VAL_132:.*]] = %[[VAL_62]]) -> (index, i32) {
1221 // CHECK: fir.store %[[VAL_132]] to %[[VAL_23]] : !fir.ref<i32>
1222 // CHECK: %[[VAL_133:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
1223 // CHECK: %[[VAL_134:.*]] = fir.convert %[[VAL_133]] : (i32) -> i64
1224 // CHECK: %[[VAL_135:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
1225 // CHECK: %[[VAL_136:.*]] = fir.convert %[[VAL_135]] : (i32) -> i64
1226 // CHECK: %[[VAL_137:.*]] = fir.load %[[VAL_18]] : !fir.ref<i32>
1227 // CHECK: %[[VAL_138:.*]] = fir.convert %[[VAL_137]] : (i32) -> i64
1228 // CHECK: %[[VAL_139:.*]] = fir.array_coor %[[VAL_37]](%[[VAL_35]]) %[[VAL_134]], %[[VAL_136]], %[[VAL_138]] : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>, i64, i64, i64) -> !fir.ref<f32>
1229 // CHECK: %[[VAL_140:.*]] = fir.load %[[VAL_139]] : !fir.ref<f32>
1230 // CHECK: %[[VAL_141:.*]] = fir.load %[[VAL_28]] : !fir.ref<f32>
1231 // CHECK: %[[VAL_142:.*]] = arith.cmpf ogt, %[[VAL_140]], %[[VAL_141]] : f32
1232 // CHECK: fir.if %[[VAL_142]] {
1233 // CHECK: %[[VAL_143:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
1234 // CHECK: %[[VAL_144:.*]] = fir.convert %[[VAL_143]] : (i32) -> i64
1235 // CHECK: %[[VAL_145:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
1236 // CHECK: %[[VAL_146:.*]] = fir.convert %[[VAL_145]] : (i32) -> i64
1237 // CHECK: %[[VAL_147:.*]] = fir.load %[[VAL_18]] : !fir.ref<i32>
1238 // CHECK: %[[VAL_148:.*]] = fir.convert %[[VAL_147]] : (i32) -> i64
1239 // CHECK: %[[VAL_149:.*]] = fir.array_coor %[[VAL_37]](%[[VAL_35]]) %[[VAL_144]], %[[VAL_146]], %[[VAL_148]] : (!fir.box<!fir.array<?x?x?xf32>>, !fir.shift<3>, i64, i64, i64) -> !fir.ref<f32>
1240 // CHECK: %[[VAL_150:.*]] = fir.load %[[VAL_149]] : !fir.ref<f32>
1241 // CHECK: fir.store %[[VAL_150]] to %[[VAL_28]] : !fir.ref<f32>
1242 // CHECK: } else {
1243 // CHECK: }
1244 // CHECK: %[[VAL_151:.*]] = arith.addi %[[VAL_131]], %[[VAL_11]] : index
1245 // CHECK: %[[VAL_152:.*]] = fir.convert %[[VAL_11]] : (index) -> i32
1246 // CHECK: %[[VAL_153:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
1247 // CHECK: %[[VAL_154:.*]] = arith.addi %[[VAL_153]], %[[VAL_152]] : i32
1248 // CHECK: fir.result %[[VAL_151]], %[[VAL_154]] : index, i32
1249 // CHECK: }
1250 // CHECK: fir.result %[[VAL_155:.*]]#0, %[[VAL_155]]#1 : index, i32
1251 // CHECK: }
1252 // CHECK: fir.store %[[VAL_156:.*]]#1 to %[[VAL_23]] : !fir.ref<i32>
1253 // CHECK: %[[VAL_157:.*]] = arith.addi %[[VAL_55]], %[[VAL_11]] : index
1254 // CHECK: %[[VAL_158:.*]] = fir.convert %[[VAL_11]] : (index) -> i32
1255 // CHECK: %[[VAL_159:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
1256 // CHECK: %[[VAL_160:.*]] = arith.addi %[[VAL_159]], %[[VAL_158]] : i32
1257 // CHECK: fir.result %[[VAL_157]], %[[VAL_160]] : index, i32
1258 // CHECK: }
1259 // CHECK: fir.store %[[VAL_161:.*]]#1 to %[[VAL_13]] : !fir.ref<i32>
1260 // CHECK: %[[VAL_162:.*]] = arith.addi %[[VAL_47]], %[[VAL_11]] : index
1261 // CHECK: %[[VAL_163:.*]] = fir.convert %[[VAL_11]] : (index) -> i32
1262 // CHECK: %[[VAL_164:.*]] = fir.load %[[VAL_18]] : !fir.ref<i32>
1263 // CHECK: %[[VAL_165:.*]] = arith.addi %[[VAL_164]], %[[VAL_163]] : i32
1264 // CHECK: fir.result %[[VAL_162]], %[[VAL_165]] : index, i32
1265 // CHECK: }
1266 // CHECK: fir.store %[[VAL_166:.*]]#1 to %[[VAL_18]] : !fir.ref<i32>
1267 // CHECK: return
1268 // CHECK: }
1270 // ! Verify that neither of the loops is versioned
1271 // ! due to the array section in the inner loop:
1272 // subroutine test_slice(x)
1273 // real :: x(:,:)
1274 // do i=10,100
1275 // x(i,7) = 1.0
1276 // x(i,3:5) = 2.0
1277 // end do
1278 // end subroutine test_slice
1279 func.func @_QPtest_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}) {
1280 %c10 = arith.constant 10 : index
1281 %c100 = arith.constant 100 : index
1282 %c6_i64 = arith.constant 6 : i64
1283 %c3 = arith.constant 3 : index
1284 %c2 = arith.constant 2 : index
1285 %c5 = arith.constant 5 : index
1286 %cst = arith.constant 2.000000e+00 : f32
1287 %c0 = arith.constant 0 : index
1288 %c1_i64 = arith.constant 1 : i64
1289 %cst_0 = arith.constant 1.000000e+00 : f32
1290 %c1 = arith.constant 1 : index
1291 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_sliceEi"}
1292 %1 = fir.convert %c10 : (index) -> i32
1293 %2:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %1) -> (index, i32) {
1294 fir.store %arg2 to %0 : !fir.ref<i32>
1295 %3 = fir.load %0 : !fir.ref<i32>
1296 %4 = fir.convert %3 : (i32) -> i64
1297 %5 = arith.subi %4, %c1_i64 : i64
1298 %6 = fir.coordinate_of %arg0, %5, %c6_i64 : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
1299 fir.store %cst_0 to %6 : !fir.ref<f32>
1300 %7 = fir.load %0 : !fir.ref<i32>
1301 %8 = fir.convert %7 : (i32) -> i64
1302 %9 = fir.undefined index
1303 %10 = fir.convert %7 : (i32) -> index
1304 %11 = fir.slice %8, %9, %9, %c3, %c5, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2>
1305 %12 = fir.undefined !fir.array<?x?xf32>
1306 %13 = fir.do_loop %arg3 = %c0 to %c2 step %c1 unordered iter_args(%arg4 = %12) -> (!fir.array<?x?xf32>) {
1307 %18 = arith.addi %arg3, %c1 : index
1308 %19 = fir.array_coor %arg0 [%11] %10, %18 : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>, index, index) -> !fir.ref<f32>
1309 fir.store %cst to %19 : !fir.ref<f32>
1310 fir.result %12 : !fir.array<?x?xf32>
1311 }
1312 %14 = arith.addi %arg1, %c1 : index
1313 %15 = fir.convert %c1 : (index) -> i32
1314 %16 = fir.load %0 : !fir.ref<i32>
1315 %17 = arith.addi %16, %15 : i32
1316 fir.result %14, %17 : index, i32
1317 }
1318 fir.store %2#1 to %0 : !fir.ref<i32>
1319 return
1320 }
1321 // CHECK-LABEL: func.func @_QPtest_slice(
1322 // CHECK-NOT: fir.if
1324 // ! Verify versioning for argument 'x' but not for 'y':
1325 // subroutine test_independent_args(x, y)
1326 // real :: x(:,:), y(:,:)
1327 // do i=10,100
1328 // x(i,7) = 1.0
1329 // y(i,3:5) = 2.0
1330 // end do
1331 // end subroutine test_independent_args
1332 func.func @_QPtest_independent_args(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) {
1333 %c10 = arith.constant 10 : index
1334 %c100 = arith.constant 100 : index
1335 %c6_i64 = arith.constant 6 : i64
1336 %c3 = arith.constant 3 : index
1337 %c2 = arith.constant 2 : index
1338 %c5 = arith.constant 5 : index
1339 %cst = arith.constant 2.000000e+00 : f32
1340 %c0 = arith.constant 0 : index
1341 %c1_i64 = arith.constant 1 : i64
1342 %cst_0 = arith.constant 1.000000e+00 : f32
1343 %c1 = arith.constant 1 : index
1344 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_independent_argsEi"}
1345 %1 = fir.convert %c10 : (index) -> i32
1346 %2:2 = fir.do_loop %arg2 = %c10 to %c100 step %c1 iter_args(%arg3 = %1) -> (index, i32) {
1347 fir.store %arg3 to %0 : !fir.ref<i32>
1348 %3 = fir.load %0 : !fir.ref<i32>
1349 %4 = fir.convert %3 : (i32) -> i64
1350 %5 = arith.subi %4, %c1_i64 : i64
1351 %6 = fir.coordinate_of %arg0, %5, %c6_i64 : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
1352 fir.store %cst_0 to %6 : !fir.ref<f32>
1353 %7 = fir.load %0 : !fir.ref<i32>
1354 %8 = fir.convert %7 : (i32) -> i64
1355 %9 = fir.undefined index
1356 %10 = fir.convert %7 : (i32) -> index
1357 %11 = fir.slice %8, %9, %9, %c3, %c5, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2>
1358 %12 = fir.undefined !fir.array<?x?xf32>
1359 %13 = fir.do_loop %arg4 = %c0 to %c2 step %c1 unordered iter_args(%arg5 = %12) -> (!fir.array<?x?xf32>) {
1360 %18 = arith.addi %arg4, %c1 : index
1361 %19 = fir.array_coor %arg1 [%11] %10, %18 : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>, index, index) -> !fir.ref<f32>
1362 fir.store %cst to %19 : !fir.ref<f32>
1363 fir.result %12 : !fir.array<?x?xf32>
1364 }
1365 %14 = arith.addi %arg2, %c1 : index
1366 %15 = fir.convert %c1 : (index) -> i32
1367 %16 = fir.load %0 : !fir.ref<i32>
1368 %17 = arith.addi %16, %15 : i32
1369 fir.result %14, %17 : index, i32
1370 }
1371 fir.store %2#1 to %0 : !fir.ref<i32>
1372 return
1373 }
1374 // CHECK-LABEL: func.func @_QPtest_independent_args(
1375 // CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"},
1376 // CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) {
1377 // CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_0]], %{{.*}} : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1378 // CHECK: %[[VAL_19:.*]] = arith.constant 4 : index
1379 // CHECK: %[[VAL_20:.*]] = arith.cmpi eq, %[[VAL_16]]#2, %[[VAL_19]] : index
1380 // CHECK: %[[VAL_21:.*]]:2 = fir.if %[[VAL_20]] -> (index, i32) {
1381 // CHECK-NOT: fir.if
1384 // ! Verify that the whole loop nest is versioned
1385 // ! without additional contiguity check for the inner loop:
1386 // subroutine test_loop_nest(x)
1387 // real :: x(:)
1388 // do i=10,100
1389 // x(i) = 1.0
1390 // do j=10,100
1391 // x(j) = 2.0
1392 // end do
1393 // end do
1394 // end subroutine test_loop_nest
1395 func.func @_QPtest_loop_nest(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x"}) {
1396 %c10 = arith.constant 10 : index
1397 %c100 = arith.constant 100 : index
1398 %cst = arith.constant 2.000000e+00 : f32
1399 %c1_i64 = arith.constant 1 : i64
1400 %cst_0 = arith.constant 1.000000e+00 : f32
1401 %c1 = arith.constant 1 : index
1402 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_loop_nestEi"}
1403 %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFtest_loop_nestEj"}
1404 %2 = fir.convert %c10 : (index) -> i32
1405 %3:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %2) -> (index, i32) {
1406 fir.store %arg2 to %0 : !fir.ref<i32>
1407 %4 = fir.load %0 : !fir.ref<i32>
1408 %5 = fir.convert %4 : (i32) -> i64
1409 %6 = arith.subi %5, %c1_i64 : i64
1410 %7 = fir.coordinate_of %arg0, %6 : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
1411 fir.store %cst_0 to %7 : !fir.ref<f32>
1412 %8:2 = fir.do_loop %arg3 = %c10 to %c100 step %c1 iter_args(%arg4 = %2) -> (index, i32) {
1413 fir.store %arg4 to %1 : !fir.ref<i32>
1414 %13 = fir.load %1 : !fir.ref<i32>
1415 %14 = fir.convert %13 : (i32) -> i64
1416 %15 = arith.subi %14, %c1_i64 : i64
1417 %16 = fir.coordinate_of %arg0, %15 : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
1418 fir.store %cst to %16 : !fir.ref<f32>
1419 %17 = arith.addi %arg3, %c1 : index
1420 %18 = fir.convert %c1 : (index) -> i32
1421 %19 = fir.load %1 : !fir.ref<i32>
1422 %20 = arith.addi %19, %18 : i32
1423 fir.result %17, %20 : index, i32
1424 }
1425 fir.store %8#1 to %1 : !fir.ref<i32>
1426 %9 = arith.addi %arg1, %c1 : index
1427 %10 = fir.convert %c1 : (index) -> i32
1428 %11 = fir.load %0 : !fir.ref<i32>
1429 %12 = arith.addi %11, %10 : i32
1430 fir.result %9, %12 : index, i32
1431 }
1432 fir.store %3#1 to %0 : !fir.ref<i32>
1433 return
1434 }
1435 // CHECK-LABEL: func.func @_QPtest_loop_nest(
1436 // CHECK: fir.if
1437 // CHECK-NOT: fir.if
1440 //-----
1442 // Check that a non-dominating operand isn't causing a problem.
1443 // Just check it compiles, and doesn't version this loop.
1444 func.func @sum1drebox(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {
1445 %decl = fir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
1446 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMmoduleFsum1dEi"}
1447 %1 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QMmoduleFsum1dEsum"}
1448 %cst = arith.constant 0.000000e+00 : f64
1449 fir.store %cst to %1 : !fir.ref<f64>
1450 %c1_i32 = arith.constant 1 : i32
1451 %2 = fir.convert %c1_i32 : (i32) -> index
1452 %3 = fir.load %arg1 : !fir.ref<i32>
1453 %4 = fir.convert %3 : (i32) -> index
1454 %c1 = arith.constant 1 : index
1455 %5 = fir.convert %2 : (index) -> i32
1456 %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) {
1457 // rebox is not dominating the loop.
1458 %rebox = fir.rebox %decl : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>>
1459 fir.store %arg3 to %0 : !fir.ref<i32>
1460 %7 = fir.load %1 : !fir.ref<f64>
1461 %8 = fir.load %0 : !fir.ref<i32>
1462 %9 = fir.convert %8 : (i32) -> i64
1463 %c1_i64 = arith.constant 1 : i64
1464 %10 = arith.subi %9, %c1_i64 : i64
1465 %11 = fir.coordinate_of %rebox, %10 : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64>
1466 %12 = fir.load %11 : !fir.ref<f64>
1467 %13 = arith.addf %7, %12 fastmath<contract> : f64
1468 fir.store %13 to %1 : !fir.ref<f64>
1469 %14 = arith.addi %arg2, %c1 : index
1470 %15 = fir.convert %c1 : (index) -> i32
1471 %16 = fir.load %0 : !fir.ref<i32>
1472 %17 = arith.addi %16, %15 : i32
1473 fir.result %14, %17 : index, i32
1474 }
1475 fir.store %6#1 to %0 : !fir.ref<i32>
1476 return
1477 }
1478 // CHECK-LABEL: func @sum1drebox
1479 // No versioning -> no if-operation.
1480 // CHECK-NOT: fir.if
1483 // Check for a use in a different block (%12 = do_loop is used inside the if %14 block)
1484 func.func @minloc(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "mask"}) -> f32 {
1485 %c2147483647_i32 = arith.constant 2147483647 : i32
1486 %c1_i32 = arith.constant 1 : i32
1487 %c0 = arith.constant 0 : index
1488 %c0_i32 = arith.constant 0 : i32
1489 %c5_i32 = arith.constant 5 : i32
1490 %c5 = arith.constant 5 : index
1491 %c1 = arith.constant 1 : index
1492 %0 = fir.alloca i32
1493 %1 = fir.alloca !fir.array<1xi32>
1494 %2 = fir.declare %arg1 {uniq_name = "_QFtestEmask"} : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
1495 %3 = fir.rebox %2 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
1496 %4 = fir.alloca f32 {bindc_name = "test", uniq_name = "_QFtestEtest"}
1497 %5 = fir.declare %4 {uniq_name = "_QFtestEtest"} : (!fir.ref<f32>) -> !fir.ref<f32>
1498 %6 = fir.declare %arg0 {uniq_name = "_QFtestEx"} : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
1499 %7 = fir.rebox %6 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
1500 %8 = fir.shape %c1 : (index) -> !fir.shape<1>
1501 %9 = fir.array_coor %1(%8) %c1 : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
1502 fir.store %c0_i32 to %9 : !fir.ref<i32>
1503 fir.store %c0_i32 to %0 : !fir.ref<i32>
1504 %10:3 = fir.box_dims %7, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
1505 %11 = arith.subi %10#1, %c1 : index
1506 %12 = fir.do_loop %arg2 = %c0 to %11 step %c1 iter_args(%arg3 = %c2147483647_i32) -> (i32) {
1507 %18 = arith.addi %arg2, %c1 : index
1508 %19 = fir.array_coor %3 %18 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
1509 %20 = fir.load %19 : !fir.ref<i32>
1510 %21 = arith.cmpi sge, %20, %c5_i32 : i32
1511 %22 = fir.if %21 -> (i32) {
1512 fir.store %c1_i32 to %0 : !fir.ref<i32>
1513 %23 = arith.subi %10#0, %c1 : index
1514 %24 = arith.addi %18, %23 : index
1515 %25 = fir.array_coor %7 %24 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
1516 %26 = fir.load %25 : !fir.ref<i32>
1517 %27 = arith.cmpi slt, %26, %arg3 : i32
1518 %28 = fir.if %27 -> (i32) {
1519 %29 = fir.convert %18 : (index) -> i32
1520 fir.store %29 to %9 : !fir.ref<i32>
1521 fir.result %26 : i32
1522 } else {
1523 fir.result %arg3 : i32
1524 }
1525 fir.result %28 : i32
1526 } else {
1527 fir.result %arg3 : i32
1528 }
1529 fir.result %22 : i32
1530 }
1531 %13 = fir.load %0 : !fir.ref<i32>
1532 %14 = arith.cmpi eq, %13, %c1_i32 : i32
1533 fir.if %14 {
1534 %18 = arith.cmpi eq, %12, %c2147483647_i32 : i32
1535 fir.if %18 {
1536 %19 = fir.array_coor %1(%8) %c0 : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
1537 fir.store %c1_i32 to %19 : !fir.ref<i32>
1538 }
1539 }
1540 %15 = fir.slice %c5, %c5, %c1 : (index, index, index) -> !fir.slice<1>
1541 %16 = fir.rebox %7 [%15] : (!fir.box<!fir.array<?xi32>>, !fir.slice<1>) -> !fir.box<!fir.array<1xi32>>
1542 fir.do_loop %arg2 = %c1 to %c1 step %c1 unordered {
1543 %18 = fir.array_coor %1(%8) %arg2 : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
1544 %19 = fir.load %18 : !fir.ref<i32>
1545 %20 = fir.array_coor %16 %arg2 : (!fir.box<!fir.array<1xi32>>, index) -> !fir.ref<i32>
1546 fir.store %19 to %20 : !fir.ref<i32>
1547 }
1548 %17 = fir.load %5 : !fir.ref<f32>
1549 return %17 : f32
1550 }
1551 // CHECK-LABEL: func @minloc
1552 // CHECK: %[[V17:.*]] = fir.if %{{.*}} -> (i32) {
1553 // CHECK: %[[V27:.*]] = fir.do_loop
1554 // CHECK: fir.result %[[V27]] : i32
1555 // CHECK: } else {
1556 // CHECK: %[[V23:.*]] = fir.do_loop
1557 // CHECK: fir.result %[[V23]] : i32
1558 // CHECK: fir.if %{{.*}} {
1559 // CHECK: {{.*}} = arith.cmpi eq, %[[V17]], %c2147483647_i32
1561 func.func @_QPtest_real10(%arg0: !fir.box<!fir.array<?x?xf80>> {fir.bindc_name = "a"}) -> f80 {
1562 %c10 = arith.constant 10 : index
1563 %c1 = arith.constant 1 : index
1564 %cst = arith.constant 0.000000e+00 : f80
1565 %0 = fir.declare %arg0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_real10Ea"} : (!fir.box<!fir.array<?x?xf80>>) -> !fir.box<!fir.array<?x?xf80>>
1566 %1 = fir.rebox %0 : (!fir.box<!fir.array<?x?xf80>>) -> !fir.box<!fir.array<?x?xf80>>
1567 %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_real10Ei"}
1568 %3 = fir.declare %2 {uniq_name = "_QFtest_real10Ei"} : (!fir.ref<i32>) -> !fir.ref<i32>
1569 %4 = fir.alloca f80 {bindc_name = "res", uniq_name = "_QFtest_real10Eres"}
1570 %5 = fir.declare %4 {uniq_name = "_QFtest_real10Eres"} : (!fir.ref<f80>) -> !fir.ref<f80>
1571 %6 = fir.address_of(@_QFtest_real10ECxdp) : !fir.ref<i32>
1572 %7 = fir.declare %6 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QFtest_real10ECxdp"} : (!fir.ref<i32>) -> !fir.ref<i32>
1573 fir.store %cst to %5 : !fir.ref<f80>
1574 %8 = fir.convert %c1 : (index) -> i32
1575 %9:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %8) -> (index, i32) {
1576 fir.store %arg2 to %3 : !fir.ref<i32>
1577 %11 = fir.load %5 : !fir.ref<f80>
1578 %12 = fir.load %3 : !fir.ref<i32>
1579 %13 = fir.convert %12 : (i32) -> i64
1580 %14 = fir.array_coor %1 %13, %13 : (!fir.box<!fir.array<?x?xf80>>, i64, i64) -> !fir.ref<f80>
1581 %15 = fir.load %14 : !fir.ref<f80>
1582 %16 = arith.addf %11, %15 fastmath<contract> : f80
1583 fir.store %16 to %5 : !fir.ref<f80>
1584 %17 = arith.addi %arg1, %c1 : index
1585 %18 = fir.load %3 : !fir.ref<i32>
1586 %19 = arith.addi %18, %8 : i32
1587 fir.result %17, %19 : index, i32
1588 }
1589 fir.store %9#1 to %3 : !fir.ref<i32>
1590 %10 = fir.load %5 : !fir.ref<f80>
1591 return %10 : f80
1592 }
1593 // CHECK-LABEL: func.func @_QPtest_real10(
1594 // CHECK: fir.if
1595 // CHECK: fir.do_loop
1596 // CHECK-DAG: arith.shrsi %{{[^,]*}}, %[[SHIFT:.*]] : index
1597 // CHECK-DAG: %[[SHIFT]] = arith.constant 4 : index
1598 // CHECK: fir.result
1599 // CHECK: } else {
1600 // CHECK: fir.do_loop
1602 func.func @_QPtest_complex10(%arg0: !fir.box<!fir.array<?x?xcomplex<f80>>> {fir.bindc_name = "a"}) -> complex<f80> {
1603 %c10 = arith.constant 10 : index
1604 %c1 = arith.constant 1 : index
1605 %cst = arith.constant 0.000000e+00 : f80
1606 %0 = fir.declare %arg0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_complex10Ea"} : (!fir.box<!fir.array<?x?xcomplex<f80>>>) -> !fir.box<!fir.array<?x?xcomplex<f80>>>
1607 %1 = fir.rebox %0 : (!fir.box<!fir.array<?x?xcomplex<f80>>>) -> !fir.box<!fir.array<?x?xcomplex<f80>>>
1608 %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_complex10Ei"}
1609 %3 = fir.declare %2 {uniq_name = "_QFtest_complex10Ei"} : (!fir.ref<i32>) -> !fir.ref<i32>
1610 %4 = fir.alloca complex<f80> {bindc_name = "res", uniq_name = "_QFtest_complex10Eres"}
1611 %5 = fir.declare %4 {uniq_name = "_QFtest_complex10Eres"} : (!fir.ref<complex<f80>>) -> !fir.ref<complex<f80>>
1612 %6 = fir.address_of(@_QFtest_complex10ECxdp) : !fir.ref<i32>
1613 %7 = fir.declare %6 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QFtest_complex10ECxdp"} : (!fir.ref<i32>) -> !fir.ref<i32>
1614 %8 = fir.undefined complex<f80>
1615 %9 = fir.insert_value %8, %cst, [0 : index] : (complex<f80>, f80) -> complex<f80>
1616 %10 = fir.insert_value %9, %cst, [1 : index] : (complex<f80>, f80) -> complex<f80>
1617 fir.store %10 to %5 : !fir.ref<complex<f80>>
1618 %11 = fir.convert %c1 : (index) -> i32
1619 %12:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %11) -> (index, i32) {
1620 fir.store %arg2 to %3 : !fir.ref<i32>
1621 %14 = fir.load %5 : !fir.ref<complex<f80>>
1622 %15 = fir.load %3 : !fir.ref<i32>
1623 %16 = fir.convert %15 : (i32) -> i64
1624 %17 = fir.array_coor %1 %16, %16 : (!fir.box<!fir.array<?x?xcomplex<f80>>>, i64, i64) -> !fir.ref<complex<f80>>
1625 %18 = fir.load %17 : !fir.ref<complex<f80>>
1626 %19 = fir.addc %14, %18 {fastmath = #arith.fastmath<contract>} : complex<f80>
1627 fir.store %19 to %5 : !fir.ref<complex<f80>>
1628 %20 = arith.addi %arg1, %c1 : index
1629 %21 = fir.load %3 : !fir.ref<i32>
1630 %22 = arith.addi %21, %11 : i32
1631 fir.result %20, %22 : index, i32
1632 }
1633 fir.store %12#1 to %3 : !fir.ref<i32>
1634 %13 = fir.load %5 : !fir.ref<complex<f80>>
1635 return %13 : complex<f80>
1636 }
1637 // CHECK-LABEL: func.func @_QPtest_complex10(
1638 // CHECK: fir.if
1639 // CHECK: fir.do_loop
1640 // CHECK-DAG: arith.shrsi %{{[^,]*}}, %[[SHIFT:.*]] : index
1641 // CHECK-DAG: %[[SHIFT]] = arith.constant 5 : index
1642 // CHECK: fir.result
1643 // CHECK: } else {
1644 // CHECK: fir.do_loop
1646 // Test that the loop is not versioned with non-contiguous slices:
1647 //subroutine test_step2_slice(x, y)
1648 // real :: x(:,:), y(:,:)
1649 // do i=1,10
1650 // x(::2,i) = y(::2,i) + 1.0
1651 // end do
1652 //end subroutine
1653 func.func @_QPtest_step2_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) {
1654 %c10 = arith.constant 10 : index
1655 %cst = arith.constant 1.000000e+00 : f32
1656 %c2 = arith.constant 2 : index
1657 %c0 = arith.constant 0 : index
1658 %c1 = arith.constant 1 : index
1659 %0 = fir.dummy_scope : !fir.dscope
1660 %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_step2_sliceEi"}
1661 %2 = fir.declare %1 {uniq_name = "_QFtest_step2_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1662 %3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_step2_sliceEx"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>>
1663 %4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>>
1664 %5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_step2_sliceEy"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>>
1665 %6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>>
1666 %7 = fir.convert %c1 : (index) -> i32
1667 %8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) {
1668 fir.store %arg3 to %2 : !fir.ref<i32>
1669 %9:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1670 %10 = arith.addi %9#1, %c1 : index
1671 %11 = arith.divsi %10, %c2 : index
1672 %12 = arith.cmpi sgt, %11, %c0 : index
1673 %13 = arith.select %12, %11, %c0 : index
1674 %14 = fir.load %2 : !fir.ref<i32>
1675 %15 = fir.convert %14 : (i32) -> i64
1676 %16 = fir.undefined index
1677 %17 = fir.slice %c1, %9#1, %c2, %15, %16, %16 : (index, index, index, i64, index, index) -> !fir.slice<2>
1678 %18 = fir.rebox %6 [%17] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
1679 %19:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1680 %20 = fir.slice %c1, %19#1, %c2, %15, %16, %16 : (index, index, index, i64, index, index) -> !fir.slice<2>
1681 %21 = fir.rebox %4 [%20] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
1682 fir.do_loop %arg4 = %c1 to %13 step %c1 unordered {
1683 %25 = fir.array_coor %18 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1684 %26 = fir.load %25 : !fir.ref<f32>
1685 %27 = arith.addf %26, %cst fastmath<fast> : f32
1686 %28 = fir.array_coor %21 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1687 fir.store %27 to %28 : !fir.ref<f32>
1688 }
1689 %22 = arith.addi %arg2, %c1 overflow<nsw> : index
1690 %23 = fir.load %2 : !fir.ref<i32>
1691 %24 = arith.addi %23, %7 overflow<nsw> : i32
1692 fir.result %22, %24 : index, i32
1693 }
1694 fir.store %8#1 to %2 : !fir.ref<i32>
1695 return
1696 }
1697 // CHECK-LABEL: func.func @_QPtest_step2_slice(
1698 // CHECK-NOT: fir.if
1700 // Test that the loop is versioned with most probably
1701 // contiguous slices:
1702 //subroutine test_step1_slice(x, y)
1703 // real :: x(:,:), y(:,:)
1704 // do i=1,10
1705 // x(:,i) = y(:,i) + 1.0
1706 // end do
1707 //end subroutine
1708 func.func @_QPtest_step1_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) {
1709 %c10 = arith.constant 10 : index
1710 %cst = arith.constant 1.000000e+00 : f32
1711 %c0 = arith.constant 0 : index
1712 %c1 = arith.constant 1 : index
1713 %0 = fir.dummy_scope : !fir.dscope
1714 %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_step1_sliceEi"}
1715 %2 = fir.declare %1 {uniq_name = "_QFtest_step1_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1716 %3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_step1_sliceEx"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>>
1717 %4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>>
1718 %5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_step1_sliceEy"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>>
1719 %6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>>
1720 %7 = fir.convert %c1 : (index) -> i32
1721 %8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) {
1722 fir.store %arg3 to %2 : !fir.ref<i32>
1723 %9:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1724 %10 = arith.cmpi sgt, %9#1, %c0 : index
1725 %11 = arith.select %10, %9#1, %c0 : index
1726 %12 = fir.load %2 : !fir.ref<i32>
1727 %13 = fir.convert %12 : (i32) -> i64
1728 %14 = fir.undefined index
1729 %15 = fir.slice %c1, %9#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2>
1730 %16 = fir.rebox %6 [%15] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
1731 %17:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1732 %18 = fir.slice %c1, %17#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2>
1733 %19 = fir.rebox %4 [%18] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
1734 fir.do_loop %arg4 = %c1 to %11 step %c1 unordered {
1735 %23 = fir.array_coor %16 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1736 %24 = fir.load %23 : !fir.ref<f32>
1737 %25 = arith.addf %24, %cst fastmath<fast> : f32
1738 %26 = fir.array_coor %19 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1739 fir.store %25 to %26 : !fir.ref<f32>
1740 }
1741 %20 = arith.addi %arg2, %c1 overflow<nsw> : index
1742 %21 = fir.load %2 : !fir.ref<i32>
1743 %22 = arith.addi %21, %7 overflow<nsw> : i32
1744 fir.result %20, %22 : index, i32
1745 }
1746 fir.store %8#1 to %2 : !fir.ref<i32>
1747 return
1748 }
1749 // CHECK-LABEL: func.func @_QPtest_step1_slice(
1750 // CHECK: fir.do_loop
1751 // CHECK: fir.if
1752 // CHECK: fir.do_loop
1753 // CHECK: } else {
1754 // CHECK: fir.do_loop
1756 // Test that the loop is versioned with logical arrays:
1757 //subroutine test_logical_slice(x, y)
1758 // logical :: x(:,:), y(:,:)
1759 // do i=1,10
1760 // x(:,i) = y(:,i) .or. y(i,:)
1761 // end do
1762 //end subroutine
1763 func.func @_QPtest_logical_slice(%arg0: !fir.box<!fir.array<?x?x!fir.logical<4>>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?x!fir.logical<4>>> {fir.bindc_name = "y"}) {
1764 %c10 = arith.constant 10 : index
1765 %c0 = arith.constant 0 : index
1766 %c1 = arith.constant 1 : index
1767 %0 = fir.dummy_scope : !fir.dscope
1768 %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_logical_sliceEi"}
1769 %2 = fir.declare %1 {uniq_name = "_QFtest_logical_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1770 %3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_logical_sliceEx"} : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.dscope) -> !fir.box<!fir.array<?x?x!fir.logical<4>>>
1771 %4 = fir.rebox %3 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<!fir.array<?x?x!fir.logical<4>>>
1772 %5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_logical_sliceEy"} : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.dscope) -> !fir.box<!fir.array<?x?x!fir.logical<4>>>
1773 %6 = fir.rebox %5 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<!fir.array<?x?x!fir.logical<4>>>
1774 %7 = fir.convert %c1 : (index) -> i32
1775 %8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) {
1776 fir.store %arg3 to %2 : !fir.ref<i32>
1777 %9:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, index) -> (index, index, index)
1778 %10 = arith.cmpi sgt, %9#1, %c0 : index
1779 %11 = arith.select %10, %9#1, %c0 : index
1780 %12 = fir.load %2 : !fir.ref<i32>
1781 %13 = fir.convert %12 : (i32) -> i64
1782 %14 = fir.undefined index
1783 %15 = fir.slice %c1, %9#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2>
1784 %16 = fir.rebox %6 [%15] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x!fir.logical<4>>>
1785 %17:3 = fir.box_dims %6, %c1 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, index) -> (index, index, index)
1786 %18 = fir.slice %13, %14, %14, %c1, %17#1, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2>
1787 %19 = fir.rebox %6 [%18] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x!fir.logical<4>>>
1788 %20:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, index) -> (index, index, index)
1789 %21 = fir.slice %c1, %20#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2>
1790 %22 = fir.rebox %4 [%21] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x!fir.logical<4>>>
1791 fir.do_loop %arg4 = %c1 to %11 step %c1 unordered {
1792 %26 = fir.array_coor %16 %arg4 : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
1793 %27 = fir.array_coor %19 %arg4 : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
1794 %28 = fir.load %26 : !fir.ref<!fir.logical<4>>
1795 %29 = fir.load %27 : !fir.ref<!fir.logical<4>>
1796 %30 = fir.convert %28 : (!fir.logical<4>) -> i1
1797 %31 = fir.convert %29 : (!fir.logical<4>) -> i1
1798 %32 = arith.ori %30, %31 : i1
1799 %33 = fir.convert %32 : (i1) -> !fir.logical<4>
1800 %34 = fir.array_coor %22 %arg4 : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
1801 fir.store %33 to %34 : !fir.ref<!fir.logical<4>>
1802 }
1803 %23 = arith.addi %arg2, %c1 overflow<nsw> : index
1804 %24 = fir.load %2 : !fir.ref<i32>
1805 %25 = arith.addi %24, %7 overflow<nsw> : i32
1806 fir.result %23, %25 : index, i32
1807 }
1808 fir.store %8#1 to %2 : !fir.ref<i32>
1809 return
1810 }
1811 // CHECK-LABEL: func.func @_QPtest_logical_slice(
1812 // CHECK: fir.do_loop
1813 // CHECK: fir.if
1814 // CHECK: fir.do_loop
1815 // CHECK: } else {
1816 // CHECK: fir.do_loop
1818 // Test that the loop is versioned when a most probably
1819 // contiguous slices have known shape:
1820 //subroutine test_known_shape_slice(x, y)
1821 // integer :: x(:,:), y(:,:)
1822 // do i=1,10
1823 // x(1:10,i) = y(1:10,i) + 1
1824 // end do
1825 //end subroutine
1826 func.func @_QPtest_known_shape_slice(%arg0: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "y"}) {
1827 %c10 = arith.constant 10 : index
1828 %c1 = arith.constant 1 : index
1829 %c1_i32 = arith.constant 1 : i32
1830 %0 = fir.dummy_scope : !fir.dscope
1831 %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_known_shape_sliceEi"}
1832 %2 = fir.declare %1 {uniq_name = "_QFtest_known_shape_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1833 %3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_known_shape_sliceEx"} : (!fir.box<!fir.array<?x?xi32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xi32>>
1834 %4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<!fir.array<?x?xi32>>
1835 %5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_known_shape_sliceEy"} : (!fir.box<!fir.array<?x?xi32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xi32>>
1836 %6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<!fir.array<?x?xi32>>
1837 %7 = fir.convert %c1 : (index) -> i32
1838 %8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) {
1839 fir.store %arg3 to %2 : !fir.ref<i32>
1840 %9 = fir.load %2 : !fir.ref<i32>
1841 %10 = fir.convert %9 : (i32) -> i64
1842 %11 = fir.undefined index
1843 %12 = fir.slice %c1, %c10, %c1, %10, %11, %11 : (index, index, index, i64, index, index) -> !fir.slice<2>
1844 %13 = fir.rebox %6 [%12] : (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>) -> !fir.box<!fir.array<10xi32>>
1845 %14 = fir.rebox %4 [%12] : (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>) -> !fir.box<!fir.array<10xi32>>
1846 fir.do_loop %arg4 = %c1 to %c10 step %c1 unordered {
1847 %18 = fir.array_coor %13 %arg4 : (!fir.box<!fir.array<10xi32>>, index) -> !fir.ref<i32>
1848 %19 = fir.load %18 : !fir.ref<i32>
1849 %20 = arith.addi %19, %c1_i32 : i32
1850 %21 = fir.array_coor %14 %arg4 : (!fir.box<!fir.array<10xi32>>, index) -> !fir.ref<i32>
1851 fir.store %20 to %21 : !fir.ref<i32>
1852 }
1853 %15 = arith.addi %arg2, %c1 overflow<nsw> : index
1854 %16 = fir.load %2 : !fir.ref<i32>
1855 %17 = arith.addi %16, %7 overflow<nsw> : i32
1856 fir.result %15, %17 : index, i32
1857 }
1858 fir.store %8#1 to %2 : !fir.ref<i32>
1859 return
1860 }
1861 // CHECK-LABEL: func.func @_QPtest_known_shape_slice(
1862 // CHECK: fir.do_loop
1863 // CHECK: fir.if
1864 // CHECK: fir.do_loop
1865 // CHECK: } else {
1866 // CHECK: fir.do_loop
1868 // Test that the loop is not versioned for most probably
1869 // not-contiguous slices:
1870 //subroutine test_maybe_noncontig_slice(x, y)
1871 // real :: x(:,:), y(:,:)
1872 // do i=1,10
1873 // x(i,:) = y(i,:) + 1.0
1874 // end do
1875 //end subroutine
1876 func.func @_QPtest_maybe_noncontig_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) {
1877 %c10 = arith.constant 10 : index
1878 %cst = arith.constant 1.000000e+00 : f32
1879 %c0 = arith.constant 0 : index
1880 %c1 = arith.constant 1 : index
1881 %0 = fir.dummy_scope : !fir.dscope
1882 %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_maybe_noncontig_sliceEi"}
1883 %2 = fir.declare %1 {uniq_name = "_QFtest_maybe_noncontig_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1884 %3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_maybe_noncontig_sliceEx"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>>
1885 %4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>>
1886 %5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_maybe_noncontig_sliceEy"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>>
1887 %6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>>
1888 %7 = fir.convert %c1 : (index) -> i32
1889 %8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) {
1890 fir.store %arg3 to %2 : !fir.ref<i32>
1891 %9 = fir.load %2 : !fir.ref<i32>
1892 %10 = fir.convert %9 : (i32) -> i64
1893 %11:3 = fir.box_dims %6, %c1 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1894 %12 = arith.cmpi sgt, %11#1, %c0 : index
1895 %13 = arith.select %12, %11#1, %c0 : index
1896 %14 = fir.undefined index
1897 %15 = fir.slice %10, %14, %14, %c1, %11#1, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2>
1898 %16 = fir.rebox %6 [%15] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
1899 %17:3 = fir.box_dims %4, %c1 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index)
1900 %18 = fir.slice %10, %14, %14, %c1, %17#1, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2>
1901 %19 = fir.rebox %4 [%18] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
1902 fir.do_loop %arg4 = %c1 to %13 step %c1 unordered {
1903 %23 = fir.array_coor %16 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1904 %24 = fir.load %23 : !fir.ref<f32>
1905 %25 = arith.addf %24, %cst fastmath<fast> : f32
1906 %26 = fir.array_coor %19 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
1907 fir.store %25 to %26 : !fir.ref<f32>
1908 }
1909 %20 = arith.addi %arg2, %c1 overflow<nsw> : index
1910 %21 = fir.load %2 : !fir.ref<i32>
1911 %22 = arith.addi %21, %7 overflow<nsw> : i32
1912 fir.result %20, %22 : index, i32
1913 }
1914 fir.store %8#1 to %2 : !fir.ref<i32>
1915 return
1916 }
1917 // CHECK-LABEL: func.func @_QPtest_maybe_noncontig_slice(
1918 // CHECK-NOT: fir.if
1920 // Regression test for facerec's GraphSimFct:
1921 //real function test_graphsimfct(a1, a2)
1922 // integer :: i
1923 // real, intent(in) :: a1(:,:,:)
1924 // real, intent(in) :: a2(:,:,:,:)
1925 // graphsimfct = 0.0
1926 // do i=1,10
1927 // test_graphsimfct = test_graphsimfct + SUM(a1(:,:,i) * a2(:,:,i,i))
1928 // end do
1929 //end function
1930 func.func @_QPtest_graphsimfct(%arg0: !fir.box<!fir.array<?x?x?xf32>> {fir.bindc_name = "a1"}, %arg1: !fir.box<!fir.array<?x?x?x?xf32>> {fir.bindc_name = "a2"}) -> f32 {
1931 %c10 = arith.constant 10 : index
1932 %c0 = arith.constant 0 : index
1933 %c1 = arith.constant 1 : index
1934 %cst = arith.constant 0.000000e+00 : f32
1935 %0 = fir.dummy_scope : !fir.dscope
1936 %1 = fir.declare %arg0 dummy_scope %0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_graphsimfctEa1"} : (!fir.box<!fir.array<?x?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?x?xf32>>
1937 %2 = fir.rebox %1 : (!fir.box<!fir.array<?x?x?xf32>>) -> !fir.box<!fir.array<?x?x?xf32>>
1938 %3 = fir.declare %arg1 dummy_scope %0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_graphsimfctEa2"} : (!fir.box<!fir.array<?x?x?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?x?x?xf32>>
1939 %4 = fir.rebox %3 : (!fir.box<!fir.array<?x?x?x?xf32>>) -> !fir.box<!fir.array<?x?x?x?xf32>>
1940 %5 = fir.alloca f32 {bindc_name = "graphsimfct", uniq_name = "_QFtest_graphsimfctEgraphsimfct"}
1941 %6 = fir.declare %5 {uniq_name = "_QFtest_graphsimfctEgraphsimfct"} : (!fir.ref<f32>) -> !fir.ref<f32>
1942 %7 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_graphsimfctEi"}
1943 %8 = fir.declare %7 {uniq_name = "_QFtest_graphsimfctEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
1944 %9 = fir.alloca f32 {bindc_name = "test_graphsimfct", uniq_name = "_QFtest_graphsimfctEtest_graphsimfct"}
1945 %10 = fir.declare %9 {uniq_name = "_QFtest_graphsimfctEtest_graphsimfct"} : (!fir.ref<f32>) -> !fir.ref<f32>
1946 fir.store %cst to %6 : !fir.ref<f32>
1947 %11 = fir.convert %c1 : (index) -> i32
1948 %12:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %11) -> (index, i32) {
1949 fir.store %arg3 to %8 : !fir.ref<i32>
1950 %14 = fir.load %10 : !fir.ref<f32>
1951 %15:3 = fir.box_dims %2, %c0 : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index)
1952 %16:3 = fir.box_dims %2, %c1 : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index)
1953 %17 = arith.cmpi sgt, %15#1, %c0 : index
1954 %18 = arith.select %17, %15#1, %c0 : index
1955 %19 = arith.cmpi sgt, %16#1, %c0 : index
1956 %20 = arith.select %19, %16#1, %c0 : index
1957 %21 = fir.load %8 : !fir.ref<i32>
1958 %22 = fir.convert %21 : (i32) -> i64
1959 %23 = fir.undefined index
1960 %24 = fir.slice %c1, %15#1, %c1, %c1, %16#1, %c1, %22, %23, %23 : (index, index, index, index, index, index, i64, index, index) -> !fir.slice<3>
1961 %25 = fir.rebox %2 [%24] : (!fir.box<!fir.array<?x?x?xf32>>, !fir.slice<3>) -> !fir.box<!fir.array<?x?xf32>>
1962 %26:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?x?x?xf32>>, index) -> (index, index, index)
1963 %27:3 = fir.box_dims %4, %c1 : (!fir.box<!fir.array<?x?x?x?xf32>>, index) -> (index, index, index)
1964 %28 = fir.slice %c1, %26#1, %c1, %c1, %27#1, %c1, %22, %23, %23, %22, %23, %23 : (index, index, index, index, index, index, i64, index, index, i64, index, index) -> !fir.slice<4>
1965 %29 = fir.rebox %4 [%28] : (!fir.box<!fir.array<?x?x?x?xf32>>, !fir.slice<4>) -> !fir.box<!fir.array<?x?xf32>>
1966 %30 = fir.do_loop %arg4 = %c1 to %20 step %c1 unordered iter_args(%arg5 = %cst) -> (f32) {
1967 %35 = fir.do_loop %arg6 = %c1 to %18 step %c1 unordered iter_args(%arg7 = %arg5) -> (f32) {
1968 %36 = fir.array_coor %25 %arg6, %arg4 : (!fir.box<!fir.array<?x?xf32>>, index, index) -> !fir.ref<f32>
1969 %37 = fir.array_coor %29 %arg6, %arg4 : (!fir.box<!fir.array<?x?xf32>>, index, index) -> !fir.ref<f32>
1970 %38 = fir.load %36 : !fir.ref<f32>
1971 %39 = fir.load %37 : !fir.ref<f32>
1972 %40 = arith.mulf %38, %39 fastmath<fast> : f32
1973 %41 = arith.addf %arg7, %40 fastmath<fast> : f32
1974 fir.result %41 : f32
1975 }
1976 fir.result %35 : f32
1977 }
1978 %31 = arith.addf %14, %30 fastmath<fast> : f32
1979 fir.store %31 to %10 : !fir.ref<f32>
1980 %32 = arith.addi %arg2, %c1 overflow<nsw> : index
1981 %33 = fir.load %8 : !fir.ref<i32>
1982 %34 = arith.addi %33, %11 overflow<nsw> : i32
1983 fir.result %32, %34 : index, i32
1984 }
1985 fir.store %12#1 to %8 : !fir.ref<i32>
1986 %13 = fir.load %10 : !fir.ref<f32>
1987 return %13 : f32
1988 }
1989 // CHECK-LABEL: func.func @_QPtest_graphsimfct(
1990 // CHECK: fir.do_loop
1991 // CHECK: fir.do_loop
1992 // CHECK: fir.if
1993 // CHECK: fir.do_loop
1994 // CHECK: } else {
1995 // CHECK: fir.do_loop
1997 } // End module