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