xref: /llvm-project/flang/test/Transforms/loop-versioning.fir (revision 711419e3025678511e3d26c4c30d757f9029d598)
1// RUN: fir-opt --loop-versioning %s | FileCheck %s
2
3
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
14module 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  }
48
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
77
78// -----
79
80// Test that loop-versioning pass doesn't expand known size arrays.
81func.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  }
112
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
120
121// -----
122
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
130
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
149
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: }
177
178
179// ----
180
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
191
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
239
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  }
261
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: }
284
285// -----
286
287
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
302
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  }
354
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
392
393// -----
394
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
409
410
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  }
482
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
524
525// Check that OPTIONAL argument's box is not accessed illegally
526// before the loop.
527func.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:         }
572
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:         }
666
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:         }
802
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:         }
982
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:         }
1269
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
1279func.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
1323
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
1332func.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
1382
1383
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
1395func.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
1438
1439
1440//-----
1441
1442// Check that a non-dominating operand isn't causing a problem.
1443// Just check it compiles, and doesn't version this loop.
1444func.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
1481
1482
1483// Check for a use in a different block (%12 = do_loop is used inside the if %14 block)
1484func.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
1560
1561func.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
1601
1602func.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
1645
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
1653func.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
1699
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
1708func.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
1755
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
1763func.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
1817
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
1826func.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
1867
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
1876func.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
1919
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
1930func.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
1996
1997} // End module
1998