| 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 |
| 14 |
module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<f80, dense<128> : vector<2xi64>>, #dlti.dl_entry<i128, dense<128> : vector<2xi64>>, #dlti.dl_entry<i64, dense<64> : vector<2xi64>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi64>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi64>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi64>>, #dlti.dl_entry<f128, dense<128> : vector<2xi64>>, #dlti.dl_entry<f64, dense<64> : vector<2xi64>>, #dlti.dl_entry<f16, dense<16> : vector<2xi64>>, #dlti.dl_entry<i32, dense<32> : vector<2xi64>>, #dlti.dl_entry<i16, dense<16> : vector<2xi64>>, #dlti.dl_entry<i8, dense<8> : vector<2xi64>>, #dlti.dl_entry<i1, dense<8> : vector<2xi64>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi64>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i64>>} { |
| 15 |
func.func @sum1d(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) { |
| 16 |
%decl = fir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>> |
| 17 |
%rebox = fir.rebox %decl : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>> |
| 18 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMmoduleFsum1dEi"} |
| 19 |
%1 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QMmoduleFsum1dEsum"} |
| 20 |
%cst = arith.constant 0.000000e+00 : f64 |
| 21 |
fir.store %cst to %1 : !fir.ref<f64> |
| 22 |
%c1_i32 = arith.constant 1 : i32 |
| 23 |
%2 = fir.convert %c1_i32 : (i32) -> index |
| 24 |
%3 = fir.load %arg1 : !fir.ref<i32> |
| 25 |
%4 = fir.convert %3 : (i32) -> index |
| 26 |
%c1 = arith.constant 1 : index |
| 27 |
%5 = fir.convert %2 : (index) -> i32 |
| 28 |
%6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) { |
| 29 |
fir.store %arg3 to %0 : !fir.ref<i32> |
| 30 |
%7 = fir.load %1 : !fir.ref<f64> |
| 31 |
%8 = fir.load %0 : !fir.ref<i32> |
| 32 |
%9 = fir.convert %8 : (i32) -> i64 |
| 33 |
%c1_i64 = arith.constant 1 : i64 |
| 34 |
%10 = arith.subi %9, %c1_i64 : i64 |
| 35 |
%11 = fir.coordinate_of %rebox, %10 : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64> |
| 36 |
%12 = fir.load %11 : !fir.ref<f64> |
| 37 |
%13 = arith.addf %7, %12 fastmath<contract> : f64 |
| 38 |
fir.store %13 to %1 : !fir.ref<f64> |
| 39 |
%14 = arith.addi %arg2, %c1 : index |
| 40 |
%15 = fir.convert %c1 : (index) -> i32 |
| 41 |
%16 = fir.load %0 : !fir.ref<i32> |
| 42 |
%17 = arith.addi %16, %15 : i32 |
| 43 |
fir.result %14, %17 : index, i32 |
| 44 |
} |
| 45 |
fir.store %6#1 to %0 : !fir.ref<i32> |
| 46 |
return |
| 47 |
} |
| 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. |
| 81 |
func.func @sum1dfixed(%arg0: !fir.ref<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) { |
| 82 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsum1dfixedEi"} |
| 83 |
%1 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QFsum1dfixedEsum"} |
| 84 |
%cst = arith.constant 0.000000e+00 : f64 |
| 85 |
fir.store %cst to %1 : !fir.ref<f64> |
| 86 |
%c1_i32 = arith.constant 1 : i32 |
| 87 |
%2 = fir.convert %c1_i32 : (i32) -> index |
| 88 |
%3 = fir.load %arg1 : !fir.ref<i32> |
| 89 |
%4 = fir.convert %3 : (i32) -> index |
| 90 |
%c1 = arith.constant 1 : index |
| 91 |
%5 = fir.convert %2 : (index) -> i32 |
| 92 |
%6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) { |
| 93 |
fir.store %arg3 to %0 : !fir.ref<i32> |
| 94 |
%7 = fir.load %1 : !fir.ref<f64> |
| 95 |
%8 = fir.load %0 : !fir.ref<i32> |
| 96 |
%9 = fir.convert %8 : (i32) -> i64 |
| 97 |
%c1_i64 = arith.constant 1 : i64 |
| 98 |
%10 = arith.subi %9, %c1_i64 : i64 |
| 99 |
%11 = fir.coordinate_of %arg0, %10 : (!fir.ref<!fir.array<?xf64>>, i64) -> !fir.ref<f64> |
| 100 |
%12 = fir.load %11 : !fir.ref<f64> |
| 101 |
%13 = arith.addf %7, %12 fastmath<contract> : f64 |
| 102 |
fir.store %13 to %1 : !fir.ref<f64> |
| 103 |
%14 = arith.addi %arg2, %c1 : index |
| 104 |
%15 = fir.convert %c1 : (index) -> i32 |
| 105 |
%16 = fir.load %0 : !fir.ref<i32> |
| 106 |
%17 = arith.addi %16, %15 : i32 |
| 107 |
fir.result %14, %17 : index, i32 |
| 108 |
} |
| 109 |
fir.store %6#1 to %0 : !fir.ref<i32> |
| 110 |
return |
| 111 |
} |
| 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. |
| 527 |
func.func @test_optional_arg(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) { |
| 528 |
%c1 = arith.constant 1 : index |
| 529 |
%c20 = arith.constant 20 : index |
| 530 |
%c0_i64 = arith.constant 0 : i64 |
| 531 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMcheck_modFtestEi"} |
| 532 |
%1 = fir.convert %c1 : (index) -> i32 |
| 533 |
%2:2 = fir.do_loop %arg1 = %c1 to %c20 step %c1 iter_args(%arg2 = %1) -> (index, i32) { |
| 534 |
fir.store %arg2 to %0 : !fir.ref<i32> |
| 535 |
%3 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1 |
| 536 |
fir.if %3 { |
| 537 |
%8 = fir.coordinate_of %arg0, %c0_i64 : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32> |
| 538 |
} else { |
| 539 |
} |
| 540 |
%4 = arith.addi %arg1, %c1 : index |
| 541 |
%5 = fir.convert %c1 : (index) -> i32 |
| 542 |
%6 = fir.load %0 : !fir.ref<i32> |
| 543 |
%7 = arith.addi %6, %5 : i32 |
| 544 |
fir.result %4, %7 : index, i32 |
| 545 |
} |
| 546 |
fir.store %2#1 to %0 : !fir.ref<i32> |
| 547 |
return |
| 548 |
} |
| 549 |
// CHECK-LABEL: func.func @test_optional_arg( |
| 550 |
// CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x", fir.optional}) { |
| 551 |
// CHECK-NEXT: %[[VAL_1:.*]] = arith.constant 1 : index |
| 552 |
// CHECK-NEXT: %[[VAL_2:.*]] = arith.constant 20 : index |
| 553 |
// CHECK-NEXT: %[[VAL_3:.*]] = arith.constant 0 : i64 |
| 554 |
// CHECK-NEXT: %[[VAL_4:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMcheck_modFtestEi"} |
| 555 |
// CHECK-NEXT: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (index) -> i32 |
| 556 |
// CHECK-NEXT: %[[VAL_6:.*]]:2 = fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] iter_args(%[[VAL_8:.*]] = %[[VAL_5]]) -> (index, i32) { |
| 557 |
// CHECK-NEXT: fir.store %[[VAL_8]] to %[[VAL_4]] : !fir.ref<i32> |
| 558 |
// CHECK-NEXT: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> i1 |
| 559 |
// CHECK-NEXT: fir.if %[[VAL_9]] { |
| 560 |
// CHECK-NEXT: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_3]] : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32> |
| 561 |
// CHECK-NEXT: } else { |
| 562 |
// CHECK-NEXT: } |
| 563 |
// CHECK-NEXT: %[[VAL_11:.*]] = arith.addi %[[VAL_7]], %[[VAL_1]] : index |
| 564 |
// CHECK-NEXT: %[[VAL_12:.*]] = fir.convert %[[VAL_1]] : (index) -> i32 |
| 565 |
// CHECK-NEXT: %[[VAL_13:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32> |
| 566 |
// CHECK-NEXT: %[[VAL_14:.*]] = arith.addi %[[VAL_13]], %[[VAL_12]] : i32 |
| 567 |
// CHECK-NEXT: fir.result %[[VAL_11]], %[[VAL_14]] : index, i32 |
| 568 |
// CHECK-NEXT: } |
| 569 |
// CHECK-NEXT: fir.store %[[VAL_15:.*]]#1 to %[[VAL_4]] : !fir.ref<i32> |
| 570 |
// CHECK-NEXT: return |
| 571 |
// CHECK-NEXT: } |
| 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 |
| 1279 |
func.func @_QPtest_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}) { |
| 1280 |
%c10 = arith.constant 10 : index |
| 1281 |
%c100 = arith.constant 100 : index |
| 1282 |
%c6_i64 = arith.constant 6 : i64 |
| 1283 |
%c3 = arith.constant 3 : index |
| 1284 |
%c2 = arith.constant 2 : index |
| 1285 |
%c5 = arith.constant 5 : index |
| 1286 |
%cst = arith.constant 2.000000e+00 : f32 |
| 1287 |
%c0 = arith.constant 0 : index |
| 1288 |
%c1_i64 = arith.constant 1 : i64 |
| 1289 |
%cst_0 = arith.constant 1.000000e+00 : f32 |
| 1290 |
%c1 = arith.constant 1 : index |
| 1291 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_sliceEi"} |
| 1292 |
%1 = fir.convert %c10 : (index) -> i32 |
| 1293 |
%2:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %1) -> (index, i32) { |
| 1294 |
fir.store %arg2 to %0 : !fir.ref<i32> |
| 1295 |
%3 = fir.load %0 : !fir.ref<i32> |
| 1296 |
%4 = fir.convert %3 : (i32) -> i64 |
| 1297 |
%5 = arith.subi %4, %c1_i64 : i64 |
| 1298 |
%6 = fir.coordinate_of %arg0, %5, %c6_i64 : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32> |
| 1299 |
fir.store %cst_0 to %6 : !fir.ref<f32> |
| 1300 |
%7 = fir.load %0 : !fir.ref<i32> |
| 1301 |
%8 = fir.convert %7 : (i32) -> i64 |
| 1302 |
%9 = fir.undefined index |
| 1303 |
%10 = fir.convert %7 : (i32) -> index |
| 1304 |
%11 = fir.slice %8, %9, %9, %c3, %c5, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> |
| 1305 |
%12 = fir.undefined !fir.array<?x?xf32> |
| 1306 |
%13 = fir.do_loop %arg3 = %c0 to %c2 step %c1 unordered iter_args(%arg4 = %12) -> (!fir.array<?x?xf32>) { |
| 1307 |
%18 = arith.addi %arg3, %c1 : index |
| 1308 |
%19 = fir.array_coor %arg0 [%11] %10, %18 : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>, index, index) -> !fir.ref<f32> |
| 1309 |
fir.store %cst to %19 : !fir.ref<f32> |
| 1310 |
fir.result %12 : !fir.array<?x?xf32> |
| 1311 |
} |
| 1312 |
%14 = arith.addi %arg1, %c1 : index |
| 1313 |
%15 = fir.convert %c1 : (index) -> i32 |
| 1314 |
%16 = fir.load %0 : !fir.ref<i32> |
| 1315 |
%17 = arith.addi %16, %15 : i32 |
| 1316 |
fir.result %14, %17 : index, i32 |
| 1317 |
} |
| 1318 |
fir.store %2#1 to %0 : !fir.ref<i32> |
| 1319 |
return |
| 1320 |
} |
| 1321 |
// CHECK-LABEL: func.func @_QPtest_slice( |
| 1322 |
// CHECK-NOT: fir.if |
| 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 |
| 1332 |
func.func @_QPtest_independent_args(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) { |
| 1333 |
%c10 = arith.constant 10 : index |
| 1334 |
%c100 = arith.constant 100 : index |
| 1335 |
%c6_i64 = arith.constant 6 : i64 |
| 1336 |
%c3 = arith.constant 3 : index |
| 1337 |
%c2 = arith.constant 2 : index |
| 1338 |
%c5 = arith.constant 5 : index |
| 1339 |
%cst = arith.constant 2.000000e+00 : f32 |
| 1340 |
%c0 = arith.constant 0 : index |
| 1341 |
%c1_i64 = arith.constant 1 : i64 |
| 1342 |
%cst_0 = arith.constant 1.000000e+00 : f32 |
| 1343 |
%c1 = arith.constant 1 : index |
| 1344 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_independent_argsEi"} |
| 1345 |
%1 = fir.convert %c10 : (index) -> i32 |
| 1346 |
%2:2 = fir.do_loop %arg2 = %c10 to %c100 step %c1 iter_args(%arg3 = %1) -> (index, i32) { |
| 1347 |
fir.store %arg3 to %0 : !fir.ref<i32> |
| 1348 |
%3 = fir.load %0 : !fir.ref<i32> |
| 1349 |
%4 = fir.convert %3 : (i32) -> i64 |
| 1350 |
%5 = arith.subi %4, %c1_i64 : i64 |
| 1351 |
%6 = fir.coordinate_of %arg0, %5, %c6_i64 : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32> |
| 1352 |
fir.store %cst_0 to %6 : !fir.ref<f32> |
| 1353 |
%7 = fir.load %0 : !fir.ref<i32> |
| 1354 |
%8 = fir.convert %7 : (i32) -> i64 |
| 1355 |
%9 = fir.undefined index |
| 1356 |
%10 = fir.convert %7 : (i32) -> index |
| 1357 |
%11 = fir.slice %8, %9, %9, %c3, %c5, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> |
| 1358 |
%12 = fir.undefined !fir.array<?x?xf32> |
| 1359 |
%13 = fir.do_loop %arg4 = %c0 to %c2 step %c1 unordered iter_args(%arg5 = %12) -> (!fir.array<?x?xf32>) { |
| 1360 |
%18 = arith.addi %arg4, %c1 : index |
| 1361 |
%19 = fir.array_coor %arg1 [%11] %10, %18 : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>, index, index) -> !fir.ref<f32> |
| 1362 |
fir.store %cst to %19 : !fir.ref<f32> |
| 1363 |
fir.result %12 : !fir.array<?x?xf32> |
| 1364 |
} |
| 1365 |
%14 = arith.addi %arg2, %c1 : index |
| 1366 |
%15 = fir.convert %c1 : (index) -> i32 |
| 1367 |
%16 = fir.load %0 : !fir.ref<i32> |
| 1368 |
%17 = arith.addi %16, %15 : i32 |
| 1369 |
fir.result %14, %17 : index, i32 |
| 1370 |
} |
| 1371 |
fir.store %2#1 to %0 : !fir.ref<i32> |
| 1372 |
return |
| 1373 |
} |
| 1374 |
// CHECK-LABEL: func.func @_QPtest_independent_args( |
| 1375 |
// CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, |
| 1376 |
// CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) { |
| 1377 |
// CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_0]], %{{.*}} : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1378 |
// CHECK: %[[VAL_19:.*]] = arith.constant 4 : index |
| 1379 |
// CHECK: %[[VAL_20:.*]] = arith.cmpi eq, %[[VAL_16]]#2, %[[VAL_19]] : index |
| 1380 |
// CHECK: %[[VAL_21:.*]]:2 = fir.if %[[VAL_20]] -> (index, i32) { |
| 1381 |
// CHECK-NOT: fir.if |
| 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 |
| 1395 |
func.func @_QPtest_loop_nest(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "x"}) { |
| 1396 |
%c10 = arith.constant 10 : index |
| 1397 |
%c100 = arith.constant 100 : index |
| 1398 |
%cst = arith.constant 2.000000e+00 : f32 |
| 1399 |
%c1_i64 = arith.constant 1 : i64 |
| 1400 |
%cst_0 = arith.constant 1.000000e+00 : f32 |
| 1401 |
%c1 = arith.constant 1 : index |
| 1402 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_loop_nestEi"} |
| 1403 |
%1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFtest_loop_nestEj"} |
| 1404 |
%2 = fir.convert %c10 : (index) -> i32 |
| 1405 |
%3:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %2) -> (index, i32) { |
| 1406 |
fir.store %arg2 to %0 : !fir.ref<i32> |
| 1407 |
%4 = fir.load %0 : !fir.ref<i32> |
| 1408 |
%5 = fir.convert %4 : (i32) -> i64 |
| 1409 |
%6 = arith.subi %5, %c1_i64 : i64 |
| 1410 |
%7 = fir.coordinate_of %arg0, %6 : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32> |
| 1411 |
fir.store %cst_0 to %7 : !fir.ref<f32> |
| 1412 |
%8:2 = fir.do_loop %arg3 = %c10 to %c100 step %c1 iter_args(%arg4 = %2) -> (index, i32) { |
| 1413 |
fir.store %arg4 to %1 : !fir.ref<i32> |
| 1414 |
%13 = fir.load %1 : !fir.ref<i32> |
| 1415 |
%14 = fir.convert %13 : (i32) -> i64 |
| 1416 |
%15 = arith.subi %14, %c1_i64 : i64 |
| 1417 |
%16 = fir.coordinate_of %arg0, %15 : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32> |
| 1418 |
fir.store %cst to %16 : !fir.ref<f32> |
| 1419 |
%17 = arith.addi %arg3, %c1 : index |
| 1420 |
%18 = fir.convert %c1 : (index) -> i32 |
| 1421 |
%19 = fir.load %1 : !fir.ref<i32> |
| 1422 |
%20 = arith.addi %19, %18 : i32 |
| 1423 |
fir.result %17, %20 : index, i32 |
| 1424 |
} |
| 1425 |
fir.store %8#1 to %1 : !fir.ref<i32> |
| 1426 |
%9 = arith.addi %arg1, %c1 : index |
| 1427 |
%10 = fir.convert %c1 : (index) -> i32 |
| 1428 |
%11 = fir.load %0 : !fir.ref<i32> |
| 1429 |
%12 = arith.addi %11, %10 : i32 |
| 1430 |
fir.result %9, %12 : index, i32 |
| 1431 |
} |
| 1432 |
fir.store %3#1 to %0 : !fir.ref<i32> |
| 1433 |
return |
| 1434 |
} |
| 1435 |
// CHECK-LABEL: func.func @_QPtest_loop_nest( |
| 1436 |
// CHECK: fir.if |
| 1437 |
// CHECK-NOT: fir.if |
| 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. |
| 1444 |
func.func @sum1drebox(%arg0: !fir.box<!fir.array<?xf64>> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) { |
| 1445 |
%decl = fir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>> |
| 1446 |
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMmoduleFsum1dEi"} |
| 1447 |
%1 = fir.alloca f64 {bindc_name = "sum", uniq_name = "_QMmoduleFsum1dEsum"} |
| 1448 |
%cst = arith.constant 0.000000e+00 : f64 |
| 1449 |
fir.store %cst to %1 : !fir.ref<f64> |
| 1450 |
%c1_i32 = arith.constant 1 : i32 |
| 1451 |
%2 = fir.convert %c1_i32 : (i32) -> index |
| 1452 |
%3 = fir.load %arg1 : !fir.ref<i32> |
| 1453 |
%4 = fir.convert %3 : (i32) -> index |
| 1454 |
%c1 = arith.constant 1 : index |
| 1455 |
%5 = fir.convert %2 : (index) -> i32 |
| 1456 |
%6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) { |
| 1457 |
// rebox is not dominating the loop. |
| 1458 |
%rebox = fir.rebox %decl : (!fir.box<!fir.array<?xf64>>) -> !fir.box<!fir.array<?xf64>> |
| 1459 |
fir.store %arg3 to %0 : !fir.ref<i32> |
| 1460 |
%7 = fir.load %1 : !fir.ref<f64> |
| 1461 |
%8 = fir.load %0 : !fir.ref<i32> |
| 1462 |
%9 = fir.convert %8 : (i32) -> i64 |
| 1463 |
%c1_i64 = arith.constant 1 : i64 |
| 1464 |
%10 = arith.subi %9, %c1_i64 : i64 |
| 1465 |
%11 = fir.coordinate_of %rebox, %10 : (!fir.box<!fir.array<?xf64>>, i64) -> !fir.ref<f64> |
| 1466 |
%12 = fir.load %11 : !fir.ref<f64> |
| 1467 |
%13 = arith.addf %7, %12 fastmath<contract> : f64 |
| 1468 |
fir.store %13 to %1 : !fir.ref<f64> |
| 1469 |
%14 = arith.addi %arg2, %c1 : index |
| 1470 |
%15 = fir.convert %c1 : (index) -> i32 |
| 1471 |
%16 = fir.load %0 : !fir.ref<i32> |
| 1472 |
%17 = arith.addi %16, %15 : i32 |
| 1473 |
fir.result %14, %17 : index, i32 |
| 1474 |
} |
| 1475 |
fir.store %6#1 to %0 : !fir.ref<i32> |
| 1476 |
return |
| 1477 |
} |
| 1478 |
// CHECK-LABEL: func @sum1drebox |
| 1479 |
// No versioning -> no if-operation. |
| 1480 |
// CHECK-NOT: fir.if |
| 1481 |
|
| 1482 |
|
| 1483 |
// Check for a use in a different block (%12 = do_loop is used inside the if %14 block) |
| 1484 |
func.func @minloc(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "mask"}) -> f32 { |
| 1485 |
%c2147483647_i32 = arith.constant 2147483647 : i32 |
| 1486 |
%c1_i32 = arith.constant 1 : i32 |
| 1487 |
%c0 = arith.constant 0 : index |
| 1488 |
%c0_i32 = arith.constant 0 : i32 |
| 1489 |
%c5_i32 = arith.constant 5 : i32 |
| 1490 |
%c5 = arith.constant 5 : index |
| 1491 |
%c1 = arith.constant 1 : index |
| 1492 |
%0 = fir.alloca i32 |
| 1493 |
%1 = fir.alloca !fir.array<1xi32> |
| 1494 |
%2 = fir.declare %arg1 {uniq_name = "_QFtestEmask"} : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>> |
| 1495 |
%3 = fir.rebox %2 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>> |
| 1496 |
%4 = fir.alloca f32 {bindc_name = "test", uniq_name = "_QFtestEtest"} |
| 1497 |
%5 = fir.declare %4 {uniq_name = "_QFtestEtest"} : (!fir.ref<f32>) -> !fir.ref<f32> |
| 1498 |
%6 = fir.declare %arg0 {uniq_name = "_QFtestEx"} : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>> |
| 1499 |
%7 = fir.rebox %6 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>> |
| 1500 |
%8 = fir.shape %c1 : (index) -> !fir.shape<1> |
| 1501 |
%9 = fir.array_coor %1(%8) %c1 : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>, index) -> !fir.ref<i32> |
| 1502 |
fir.store %c0_i32 to %9 : !fir.ref<i32> |
| 1503 |
fir.store %c0_i32 to %0 : !fir.ref<i32> |
| 1504 |
%10:3 = fir.box_dims %7, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) |
| 1505 |
%11 = arith.subi %10#1, %c1 : index |
| 1506 |
%12 = fir.do_loop %arg2 = %c0 to %11 step %c1 iter_args(%arg3 = %c2147483647_i32) -> (i32) { |
| 1507 |
%18 = arith.addi %arg2, %c1 : index |
| 1508 |
%19 = fir.array_coor %3 %18 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32> |
| 1509 |
%20 = fir.load %19 : !fir.ref<i32> |
| 1510 |
%21 = arith.cmpi sge, %20, %c5_i32 : i32 |
| 1511 |
%22 = fir.if %21 -> (i32) { |
| 1512 |
fir.store %c1_i32 to %0 : !fir.ref<i32> |
| 1513 |
%23 = arith.subi %10#0, %c1 : index |
| 1514 |
%24 = arith.addi %18, %23 : index |
| 1515 |
%25 = fir.array_coor %7 %24 : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32> |
| 1516 |
%26 = fir.load %25 : !fir.ref<i32> |
| 1517 |
%27 = arith.cmpi slt, %26, %arg3 : i32 |
| 1518 |
%28 = fir.if %27 -> (i32) { |
| 1519 |
%29 = fir.convert %18 : (index) -> i32 |
| 1520 |
fir.store %29 to %9 : !fir.ref<i32> |
| 1521 |
fir.result %26 : i32 |
| 1522 |
} else { |
| 1523 |
fir.result %arg3 : i32 |
| 1524 |
} |
| 1525 |
fir.result %28 : i32 |
| 1526 |
} else { |
| 1527 |
fir.result %arg3 : i32 |
| 1528 |
} |
| 1529 |
fir.result %22 : i32 |
| 1530 |
} |
| 1531 |
%13 = fir.load %0 : !fir.ref<i32> |
| 1532 |
%14 = arith.cmpi eq, %13, %c1_i32 : i32 |
| 1533 |
fir.if %14 { |
| 1534 |
%18 = arith.cmpi eq, %12, %c2147483647_i32 : i32 |
| 1535 |
fir.if %18 { |
| 1536 |
%19 = fir.array_coor %1(%8) %c0 : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>, index) -> !fir.ref<i32> |
| 1537 |
fir.store %c1_i32 to %19 : !fir.ref<i32> |
| 1538 |
} |
| 1539 |
} |
| 1540 |
%15 = fir.slice %c5, %c5, %c1 : (index, index, index) -> !fir.slice<1> |
| 1541 |
%16 = fir.rebox %7 [%15] : (!fir.box<!fir.array<?xi32>>, !fir.slice<1>) -> !fir.box<!fir.array<1xi32>> |
| 1542 |
fir.do_loop %arg2 = %c1 to %c1 step %c1 unordered { |
| 1543 |
%18 = fir.array_coor %1(%8) %arg2 : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>, index) -> !fir.ref<i32> |
| 1544 |
%19 = fir.load %18 : !fir.ref<i32> |
| 1545 |
%20 = fir.array_coor %16 %arg2 : (!fir.box<!fir.array<1xi32>>, index) -> !fir.ref<i32> |
| 1546 |
fir.store %19 to %20 : !fir.ref<i32> |
| 1547 |
} |
| 1548 |
%17 = fir.load %5 : !fir.ref<f32> |
| 1549 |
return %17 : f32 |
| 1550 |
} |
| 1551 |
// CHECK-LABEL: func @minloc |
| 1552 |
// CHECK: %[[V17:.*]] = fir.if %{{.*}} -> (i32) { |
| 1553 |
// CHECK: %[[V27:.*]] = fir.do_loop |
| 1554 |
// CHECK: fir.result %[[V27]] : i32 |
| 1555 |
// CHECK: } else { |
| 1556 |
// CHECK: %[[V23:.*]] = fir.do_loop |
| 1557 |
// CHECK: fir.result %[[V23]] : i32 |
| 1558 |
// CHECK: fir.if %{{.*}} { |
| 1559 |
// CHECK: {{.*}} = arith.cmpi eq, %[[V17]], %c2147483647_i32 |
| 1560 |
|
| 1561 |
func.func @_QPtest_real10(%arg0: !fir.box<!fir.array<?x?xf80>> {fir.bindc_name = "a"}) -> f80 { |
| 1562 |
%c10 = arith.constant 10 : index |
| 1563 |
%c1 = arith.constant 1 : index |
| 1564 |
%cst = arith.constant 0.000000e+00 : f80 |
| 1565 |
%0 = fir.declare %arg0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_real10Ea"} : (!fir.box<!fir.array<?x?xf80>>) -> !fir.box<!fir.array<?x?xf80>> |
| 1566 |
%1 = fir.rebox %0 : (!fir.box<!fir.array<?x?xf80>>) -> !fir.box<!fir.array<?x?xf80>> |
| 1567 |
%2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_real10Ei"} |
| 1568 |
%3 = fir.declare %2 {uniq_name = "_QFtest_real10Ei"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1569 |
%4 = fir.alloca f80 {bindc_name = "res", uniq_name = "_QFtest_real10Eres"} |
| 1570 |
%5 = fir.declare %4 {uniq_name = "_QFtest_real10Eres"} : (!fir.ref<f80>) -> !fir.ref<f80> |
| 1571 |
%6 = fir.address_of(@_QFtest_real10ECxdp) : !fir.ref<i32> |
| 1572 |
%7 = fir.declare %6 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QFtest_real10ECxdp"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1573 |
fir.store %cst to %5 : !fir.ref<f80> |
| 1574 |
%8 = fir.convert %c1 : (index) -> i32 |
| 1575 |
%9:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %8) -> (index, i32) { |
| 1576 |
fir.store %arg2 to %3 : !fir.ref<i32> |
| 1577 |
%11 = fir.load %5 : !fir.ref<f80> |
| 1578 |
%12 = fir.load %3 : !fir.ref<i32> |
| 1579 |
%13 = fir.convert %12 : (i32) -> i64 |
| 1580 |
%14 = fir.array_coor %1 %13, %13 : (!fir.box<!fir.array<?x?xf80>>, i64, i64) -> !fir.ref<f80> |
| 1581 |
%15 = fir.load %14 : !fir.ref<f80> |
| 1582 |
%16 = arith.addf %11, %15 fastmath<contract> : f80 |
| 1583 |
fir.store %16 to %5 : !fir.ref<f80> |
| 1584 |
%17 = arith.addi %arg1, %c1 : index |
| 1585 |
%18 = fir.load %3 : !fir.ref<i32> |
| 1586 |
%19 = arith.addi %18, %8 : i32 |
| 1587 |
fir.result %17, %19 : index, i32 |
| 1588 |
} |
| 1589 |
fir.store %9#1 to %3 : !fir.ref<i32> |
| 1590 |
%10 = fir.load %5 : !fir.ref<f80> |
| 1591 |
return %10 : f80 |
| 1592 |
} |
| 1593 |
// CHECK-LABEL: func.func @_QPtest_real10( |
| 1594 |
// CHECK: fir.if |
| 1595 |
// CHECK: fir.do_loop |
| 1596 |
// CHECK-DAG: arith.shrsi %{{[^,]*}}, %[[SHIFT:.*]] : index |
| 1597 |
// CHECK-DAG: %[[SHIFT]] = arith.constant 4 : index |
| 1598 |
// CHECK: fir.result |
| 1599 |
// CHECK: } else { |
| 1600 |
// CHECK: fir.do_loop |
| 1601 |
|
| 1602 |
func.func @_QPtest_complex10(%arg0: !fir.box<!fir.array<?x?xcomplex<f80>>> {fir.bindc_name = "a"}) -> complex<f80> { |
| 1603 |
%c10 = arith.constant 10 : index |
| 1604 |
%c1 = arith.constant 1 : index |
| 1605 |
%cst = arith.constant 0.000000e+00 : f80 |
| 1606 |
%0 = fir.declare %arg0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_complex10Ea"} : (!fir.box<!fir.array<?x?xcomplex<f80>>>) -> !fir.box<!fir.array<?x?xcomplex<f80>>> |
| 1607 |
%1 = fir.rebox %0 : (!fir.box<!fir.array<?x?xcomplex<f80>>>) -> !fir.box<!fir.array<?x?xcomplex<f80>>> |
| 1608 |
%2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_complex10Ei"} |
| 1609 |
%3 = fir.declare %2 {uniq_name = "_QFtest_complex10Ei"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1610 |
%4 = fir.alloca complex<f80> {bindc_name = "res", uniq_name = "_QFtest_complex10Eres"} |
| 1611 |
%5 = fir.declare %4 {uniq_name = "_QFtest_complex10Eres"} : (!fir.ref<complex<f80>>) -> !fir.ref<complex<f80>> |
| 1612 |
%6 = fir.address_of(@_QFtest_complex10ECxdp) : !fir.ref<i32> |
| 1613 |
%7 = fir.declare %6 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QFtest_complex10ECxdp"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1614 |
%8 = fir.undefined complex<f80> |
| 1615 |
%9 = fir.insert_value %8, %cst, [0 : index] : (complex<f80>, f80) -> complex<f80> |
| 1616 |
%10 = fir.insert_value %9, %cst, [1 : index] : (complex<f80>, f80) -> complex<f80> |
| 1617 |
fir.store %10 to %5 : !fir.ref<complex<f80>> |
| 1618 |
%11 = fir.convert %c1 : (index) -> i32 |
| 1619 |
%12:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %11) -> (index, i32) { |
| 1620 |
fir.store %arg2 to %3 : !fir.ref<i32> |
| 1621 |
%14 = fir.load %5 : !fir.ref<complex<f80>> |
| 1622 |
%15 = fir.load %3 : !fir.ref<i32> |
| 1623 |
%16 = fir.convert %15 : (i32) -> i64 |
| 1624 |
%17 = fir.array_coor %1 %16, %16 : (!fir.box<!fir.array<?x?xcomplex<f80>>>, i64, i64) -> !fir.ref<complex<f80>> |
| 1625 |
%18 = fir.load %17 : !fir.ref<complex<f80>> |
| 1626 |
%19 = fir.addc %14, %18 {fastmath = #arith.fastmath<contract>} : complex<f80> |
| 1627 |
fir.store %19 to %5 : !fir.ref<complex<f80>> |
| 1628 |
%20 = arith.addi %arg1, %c1 : index |
| 1629 |
%21 = fir.load %3 : !fir.ref<i32> |
| 1630 |
%22 = arith.addi %21, %11 : i32 |
| 1631 |
fir.result %20, %22 : index, i32 |
| 1632 |
} |
| 1633 |
fir.store %12#1 to %3 : !fir.ref<i32> |
| 1634 |
%13 = fir.load %5 : !fir.ref<complex<f80>> |
| 1635 |
return %13 : complex<f80> |
| 1636 |
} |
| 1637 |
// CHECK-LABEL: func.func @_QPtest_complex10( |
| 1638 |
// CHECK: fir.if |
| 1639 |
// CHECK: fir.do_loop |
| 1640 |
// CHECK-DAG: arith.shrsi %{{[^,]*}}, %[[SHIFT:.*]] : index |
| 1641 |
// CHECK-DAG: %[[SHIFT]] = arith.constant 5 : index |
| 1642 |
// CHECK: fir.result |
| 1643 |
// CHECK: } else { |
| 1644 |
// CHECK: fir.do_loop |
| 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 |
| 1653 |
func.func @_QPtest_step2_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) { |
| 1654 |
%c10 = arith.constant 10 : index |
| 1655 |
%cst = arith.constant 1.000000e+00 : f32 |
| 1656 |
%c2 = arith.constant 2 : index |
| 1657 |
%c0 = arith.constant 0 : index |
| 1658 |
%c1 = arith.constant 1 : index |
| 1659 |
%0 = fir.dummy_scope : !fir.dscope |
| 1660 |
%1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_step2_sliceEi"} |
| 1661 |
%2 = fir.declare %1 {uniq_name = "_QFtest_step2_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1662 |
%3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_step2_sliceEx"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>> |
| 1663 |
%4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>> |
| 1664 |
%5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_step2_sliceEy"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>> |
| 1665 |
%6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>> |
| 1666 |
%7 = fir.convert %c1 : (index) -> i32 |
| 1667 |
%8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) { |
| 1668 |
fir.store %arg3 to %2 : !fir.ref<i32> |
| 1669 |
%9:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1670 |
%10 = arith.addi %9#1, %c1 : index |
| 1671 |
%11 = arith.divsi %10, %c2 : index |
| 1672 |
%12 = arith.cmpi sgt, %11, %c0 : index |
| 1673 |
%13 = arith.select %12, %11, %c0 : index |
| 1674 |
%14 = fir.load %2 : !fir.ref<i32> |
| 1675 |
%15 = fir.convert %14 : (i32) -> i64 |
| 1676 |
%16 = fir.undefined index |
| 1677 |
%17 = fir.slice %c1, %9#1, %c2, %15, %16, %16 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1678 |
%18 = fir.rebox %6 [%17] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>> |
| 1679 |
%19:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1680 |
%20 = fir.slice %c1, %19#1, %c2, %15, %16, %16 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1681 |
%21 = fir.rebox %4 [%20] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>> |
| 1682 |
fir.do_loop %arg4 = %c1 to %13 step %c1 unordered { |
| 1683 |
%25 = fir.array_coor %18 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32> |
| 1684 |
%26 = fir.load %25 : !fir.ref<f32> |
| 1685 |
%27 = arith.addf %26, %cst fastmath<fast> : f32 |
| 1686 |
%28 = fir.array_coor %21 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32> |
| 1687 |
fir.store %27 to %28 : !fir.ref<f32> |
| 1688 |
} |
| 1689 |
%22 = arith.addi %arg2, %c1 overflow<nsw> : index |
| 1690 |
%23 = fir.load %2 : !fir.ref<i32> |
| 1691 |
%24 = arith.addi %23, %7 overflow<nsw> : i32 |
| 1692 |
fir.result %22, %24 : index, i32 |
| 1693 |
} |
| 1694 |
fir.store %8#1 to %2 : !fir.ref<i32> |
| 1695 |
return |
| 1696 |
} |
| 1697 |
// CHECK-LABEL: func.func @_QPtest_step2_slice( |
| 1698 |
// CHECK-NOT: fir.if |
| 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 |
| 1708 |
func.func @_QPtest_step1_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) { |
| 1709 |
%c10 = arith.constant 10 : index |
| 1710 |
%cst = arith.constant 1.000000e+00 : f32 |
| 1711 |
%c0 = arith.constant 0 : index |
| 1712 |
%c1 = arith.constant 1 : index |
| 1713 |
%0 = fir.dummy_scope : !fir.dscope |
| 1714 |
%1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_step1_sliceEi"} |
| 1715 |
%2 = fir.declare %1 {uniq_name = "_QFtest_step1_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1716 |
%3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_step1_sliceEx"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>> |
| 1717 |
%4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>> |
| 1718 |
%5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_step1_sliceEy"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>> |
| 1719 |
%6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>> |
| 1720 |
%7 = fir.convert %c1 : (index) -> i32 |
| 1721 |
%8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) { |
| 1722 |
fir.store %arg3 to %2 : !fir.ref<i32> |
| 1723 |
%9:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1724 |
%10 = arith.cmpi sgt, %9#1, %c0 : index |
| 1725 |
%11 = arith.select %10, %9#1, %c0 : index |
| 1726 |
%12 = fir.load %2 : !fir.ref<i32> |
| 1727 |
%13 = fir.convert %12 : (i32) -> i64 |
| 1728 |
%14 = fir.undefined index |
| 1729 |
%15 = fir.slice %c1, %9#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1730 |
%16 = fir.rebox %6 [%15] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>> |
| 1731 |
%17:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1732 |
%18 = fir.slice %c1, %17#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1733 |
%19 = fir.rebox %4 [%18] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>> |
| 1734 |
fir.do_loop %arg4 = %c1 to %11 step %c1 unordered { |
| 1735 |
%23 = fir.array_coor %16 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32> |
| 1736 |
%24 = fir.load %23 : !fir.ref<f32> |
| 1737 |
%25 = arith.addf %24, %cst fastmath<fast> : f32 |
| 1738 |
%26 = fir.array_coor %19 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32> |
| 1739 |
fir.store %25 to %26 : !fir.ref<f32> |
| 1740 |
} |
| 1741 |
%20 = arith.addi %arg2, %c1 overflow<nsw> : index |
| 1742 |
%21 = fir.load %2 : !fir.ref<i32> |
| 1743 |
%22 = arith.addi %21, %7 overflow<nsw> : i32 |
| 1744 |
fir.result %20, %22 : index, i32 |
| 1745 |
} |
| 1746 |
fir.store %8#1 to %2 : !fir.ref<i32> |
| 1747 |
return |
| 1748 |
} |
| 1749 |
// CHECK-LABEL: func.func @_QPtest_step1_slice( |
| 1750 |
// CHECK: fir.do_loop |
| 1751 |
// CHECK: fir.if |
| 1752 |
// CHECK: fir.do_loop |
| 1753 |
// CHECK: } else { |
| 1754 |
// CHECK: fir.do_loop |
| 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 |
| 1763 |
func.func @_QPtest_logical_slice(%arg0: !fir.box<!fir.array<?x?x!fir.logical<4>>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?x!fir.logical<4>>> {fir.bindc_name = "y"}) { |
| 1764 |
%c10 = arith.constant 10 : index |
| 1765 |
%c0 = arith.constant 0 : index |
| 1766 |
%c1 = arith.constant 1 : index |
| 1767 |
%0 = fir.dummy_scope : !fir.dscope |
| 1768 |
%1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_logical_sliceEi"} |
| 1769 |
%2 = fir.declare %1 {uniq_name = "_QFtest_logical_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1770 |
%3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_logical_sliceEx"} : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.dscope) -> !fir.box<!fir.array<?x?x!fir.logical<4>>> |
| 1771 |
%4 = fir.rebox %3 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<!fir.array<?x?x!fir.logical<4>>> |
| 1772 |
%5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_logical_sliceEy"} : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.dscope) -> !fir.box<!fir.array<?x?x!fir.logical<4>>> |
| 1773 |
%6 = fir.rebox %5 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<!fir.array<?x?x!fir.logical<4>>> |
| 1774 |
%7 = fir.convert %c1 : (index) -> i32 |
| 1775 |
%8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) { |
| 1776 |
fir.store %arg3 to %2 : !fir.ref<i32> |
| 1777 |
%9:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, index) -> (index, index, index) |
| 1778 |
%10 = arith.cmpi sgt, %9#1, %c0 : index |
| 1779 |
%11 = arith.select %10, %9#1, %c0 : index |
| 1780 |
%12 = fir.load %2 : !fir.ref<i32> |
| 1781 |
%13 = fir.convert %12 : (i32) -> i64 |
| 1782 |
%14 = fir.undefined index |
| 1783 |
%15 = fir.slice %c1, %9#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1784 |
%16 = fir.rebox %6 [%15] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x!fir.logical<4>>> |
| 1785 |
%17:3 = fir.box_dims %6, %c1 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, index) -> (index, index, index) |
| 1786 |
%18 = fir.slice %13, %14, %14, %c1, %17#1, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> |
| 1787 |
%19 = fir.rebox %6 [%18] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x!fir.logical<4>>> |
| 1788 |
%20:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, index) -> (index, index, index) |
| 1789 |
%21 = fir.slice %c1, %20#1, %c1, %13, %14, %14 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1790 |
%22 = fir.rebox %4 [%21] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x!fir.logical<4>>> |
| 1791 |
fir.do_loop %arg4 = %c1 to %11 step %c1 unordered { |
| 1792 |
%26 = fir.array_coor %16 %arg4 : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>> |
| 1793 |
%27 = fir.array_coor %19 %arg4 : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>> |
| 1794 |
%28 = fir.load %26 : !fir.ref<!fir.logical<4>> |
| 1795 |
%29 = fir.load %27 : !fir.ref<!fir.logical<4>> |
| 1796 |
%30 = fir.convert %28 : (!fir.logical<4>) -> i1 |
| 1797 |
%31 = fir.convert %29 : (!fir.logical<4>) -> i1 |
| 1798 |
%32 = arith.ori %30, %31 : i1 |
| 1799 |
%33 = fir.convert %32 : (i1) -> !fir.logical<4> |
| 1800 |
%34 = fir.array_coor %22 %arg4 : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>> |
| 1801 |
fir.store %33 to %34 : !fir.ref<!fir.logical<4>> |
| 1802 |
} |
| 1803 |
%23 = arith.addi %arg2, %c1 overflow<nsw> : index |
| 1804 |
%24 = fir.load %2 : !fir.ref<i32> |
| 1805 |
%25 = arith.addi %24, %7 overflow<nsw> : i32 |
| 1806 |
fir.result %23, %25 : index, i32 |
| 1807 |
} |
| 1808 |
fir.store %8#1 to %2 : !fir.ref<i32> |
| 1809 |
return |
| 1810 |
} |
| 1811 |
// CHECK-LABEL: func.func @_QPtest_logical_slice( |
| 1812 |
// CHECK: fir.do_loop |
| 1813 |
// CHECK: fir.if |
| 1814 |
// CHECK: fir.do_loop |
| 1815 |
// CHECK: } else { |
| 1816 |
// CHECK: fir.do_loop |
| 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 |
| 1826 |
func.func @_QPtest_known_shape_slice(%arg0: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "y"}) { |
| 1827 |
%c10 = arith.constant 10 : index |
| 1828 |
%c1 = arith.constant 1 : index |
| 1829 |
%c1_i32 = arith.constant 1 : i32 |
| 1830 |
%0 = fir.dummy_scope : !fir.dscope |
| 1831 |
%1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_known_shape_sliceEi"} |
| 1832 |
%2 = fir.declare %1 {uniq_name = "_QFtest_known_shape_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1833 |
%3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_known_shape_sliceEx"} : (!fir.box<!fir.array<?x?xi32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xi32>> |
| 1834 |
%4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<!fir.array<?x?xi32>> |
| 1835 |
%5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_known_shape_sliceEy"} : (!fir.box<!fir.array<?x?xi32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xi32>> |
| 1836 |
%6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<!fir.array<?x?xi32>> |
| 1837 |
%7 = fir.convert %c1 : (index) -> i32 |
| 1838 |
%8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) { |
| 1839 |
fir.store %arg3 to %2 : !fir.ref<i32> |
| 1840 |
%9 = fir.load %2 : !fir.ref<i32> |
| 1841 |
%10 = fir.convert %9 : (i32) -> i64 |
| 1842 |
%11 = fir.undefined index |
| 1843 |
%12 = fir.slice %c1, %c10, %c1, %10, %11, %11 : (index, index, index, i64, index, index) -> !fir.slice<2> |
| 1844 |
%13 = fir.rebox %6 [%12] : (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>) -> !fir.box<!fir.array<10xi32>> |
| 1845 |
%14 = fir.rebox %4 [%12] : (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>) -> !fir.box<!fir.array<10xi32>> |
| 1846 |
fir.do_loop %arg4 = %c1 to %c10 step %c1 unordered { |
| 1847 |
%18 = fir.array_coor %13 %arg4 : (!fir.box<!fir.array<10xi32>>, index) -> !fir.ref<i32> |
| 1848 |
%19 = fir.load %18 : !fir.ref<i32> |
| 1849 |
%20 = arith.addi %19, %c1_i32 : i32 |
| 1850 |
%21 = fir.array_coor %14 %arg4 : (!fir.box<!fir.array<10xi32>>, index) -> !fir.ref<i32> |
| 1851 |
fir.store %20 to %21 : !fir.ref<i32> |
| 1852 |
} |
| 1853 |
%15 = arith.addi %arg2, %c1 overflow<nsw> : index |
| 1854 |
%16 = fir.load %2 : !fir.ref<i32> |
| 1855 |
%17 = arith.addi %16, %7 overflow<nsw> : i32 |
| 1856 |
fir.result %15, %17 : index, i32 |
| 1857 |
} |
| 1858 |
fir.store %8#1 to %2 : !fir.ref<i32> |
| 1859 |
return |
| 1860 |
} |
| 1861 |
// CHECK-LABEL: func.func @_QPtest_known_shape_slice( |
| 1862 |
// CHECK: fir.do_loop |
| 1863 |
// CHECK: fir.if |
| 1864 |
// CHECK: fir.do_loop |
| 1865 |
// CHECK: } else { |
| 1866 |
// CHECK: fir.do_loop |
| 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 |
| 1876 |
func.func @_QPtest_maybe_noncontig_slice(%arg0: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?x?xf32>> {fir.bindc_name = "y"}) { |
| 1877 |
%c10 = arith.constant 10 : index |
| 1878 |
%cst = arith.constant 1.000000e+00 : f32 |
| 1879 |
%c0 = arith.constant 0 : index |
| 1880 |
%c1 = arith.constant 1 : index |
| 1881 |
%0 = fir.dummy_scope : !fir.dscope |
| 1882 |
%1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_maybe_noncontig_sliceEi"} |
| 1883 |
%2 = fir.declare %1 {uniq_name = "_QFtest_maybe_noncontig_sliceEi"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1884 |
%3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtest_maybe_noncontig_sliceEx"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>> |
| 1885 |
%4 = fir.rebox %3 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>> |
| 1886 |
%5 = fir.declare %arg1 dummy_scope %0 {uniq_name = "_QFtest_maybe_noncontig_sliceEy"} : (!fir.box<!fir.array<?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?xf32>> |
| 1887 |
%6 = fir.rebox %5 : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<!fir.array<?x?xf32>> |
| 1888 |
%7 = fir.convert %c1 : (index) -> i32 |
| 1889 |
%8:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %7) -> (index, i32) { |
| 1890 |
fir.store %arg3 to %2 : !fir.ref<i32> |
| 1891 |
%9 = fir.load %2 : !fir.ref<i32> |
| 1892 |
%10 = fir.convert %9 : (i32) -> i64 |
| 1893 |
%11:3 = fir.box_dims %6, %c1 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1894 |
%12 = arith.cmpi sgt, %11#1, %c0 : index |
| 1895 |
%13 = arith.select %12, %11#1, %c0 : index |
| 1896 |
%14 = fir.undefined index |
| 1897 |
%15 = fir.slice %10, %14, %14, %c1, %11#1, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> |
| 1898 |
%16 = fir.rebox %6 [%15] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>> |
| 1899 |
%17:3 = fir.box_dims %4, %c1 : (!fir.box<!fir.array<?x?xf32>>, index) -> (index, index, index) |
| 1900 |
%18 = fir.slice %10, %14, %14, %c1, %17#1, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> |
| 1901 |
%19 = fir.rebox %4 [%18] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>> |
| 1902 |
fir.do_loop %arg4 = %c1 to %13 step %c1 unordered { |
| 1903 |
%23 = fir.array_coor %16 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32> |
| 1904 |
%24 = fir.load %23 : !fir.ref<f32> |
| 1905 |
%25 = arith.addf %24, %cst fastmath<fast> : f32 |
| 1906 |
%26 = fir.array_coor %19 %arg4 : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32> |
| 1907 |
fir.store %25 to %26 : !fir.ref<f32> |
| 1908 |
} |
| 1909 |
%20 = arith.addi %arg2, %c1 overflow<nsw> : index |
| 1910 |
%21 = fir.load %2 : !fir.ref<i32> |
| 1911 |
%22 = arith.addi %21, %7 overflow<nsw> : i32 |
| 1912 |
fir.result %20, %22 : index, i32 |
| 1913 |
} |
| 1914 |
fir.store %8#1 to %2 : !fir.ref<i32> |
| 1915 |
return |
| 1916 |
} |
| 1917 |
// CHECK-LABEL: func.func @_QPtest_maybe_noncontig_slice( |
| 1918 |
// CHECK-NOT: fir.if |
| 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 |
| 1930 |
func.func @_QPtest_graphsimfct(%arg0: !fir.box<!fir.array<?x?x?xf32>> {fir.bindc_name = "a1"}, %arg1: !fir.box<!fir.array<?x?x?x?xf32>> {fir.bindc_name = "a2"}) -> f32 { |
| 1931 |
%c10 = arith.constant 10 : index |
| 1932 |
%c0 = arith.constant 0 : index |
| 1933 |
%c1 = arith.constant 1 : index |
| 1934 |
%cst = arith.constant 0.000000e+00 : f32 |
| 1935 |
%0 = fir.dummy_scope : !fir.dscope |
| 1936 |
%1 = fir.declare %arg0 dummy_scope %0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_graphsimfctEa1"} : (!fir.box<!fir.array<?x?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?x?xf32>> |
| 1937 |
%2 = fir.rebox %1 : (!fir.box<!fir.array<?x?x?xf32>>) -> !fir.box<!fir.array<?x?x?xf32>> |
| 1938 |
%3 = fir.declare %arg1 dummy_scope %0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFtest_graphsimfctEa2"} : (!fir.box<!fir.array<?x?x?x?xf32>>, !fir.dscope) -> !fir.box<!fir.array<?x?x?x?xf32>> |
| 1939 |
%4 = fir.rebox %3 : (!fir.box<!fir.array<?x?x?x?xf32>>) -> !fir.box<!fir.array<?x?x?x?xf32>> |
| 1940 |
%5 = fir.alloca f32 {bindc_name = "graphsimfct", uniq_name = "_QFtest_graphsimfctEgraphsimfct"} |
| 1941 |
%6 = fir.declare %5 {uniq_name = "_QFtest_graphsimfctEgraphsimfct"} : (!fir.ref<f32>) -> !fir.ref<f32> |
| 1942 |
%7 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_graphsimfctEi"} |
| 1943 |
%8 = fir.declare %7 {uniq_name = "_QFtest_graphsimfctEi"} : (!fir.ref<i32>) -> !fir.ref<i32> |
| 1944 |
%9 = fir.alloca f32 {bindc_name = "test_graphsimfct", uniq_name = "_QFtest_graphsimfctEtest_graphsimfct"} |
| 1945 |
%10 = fir.declare %9 {uniq_name = "_QFtest_graphsimfctEtest_graphsimfct"} : (!fir.ref<f32>) -> !fir.ref<f32> |
| 1946 |
fir.store %cst to %6 : !fir.ref<f32> |
| 1947 |
%11 = fir.convert %c1 : (index) -> i32 |
| 1948 |
%12:2 = fir.do_loop %arg2 = %c1 to %c10 step %c1 iter_args(%arg3 = %11) -> (index, i32) { |
| 1949 |
fir.store %arg3 to %8 : !fir.ref<i32> |
| 1950 |
%14 = fir.load %10 : !fir.ref<f32> |
| 1951 |
%15:3 = fir.box_dims %2, %c0 : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index) |
| 1952 |
%16:3 = fir.box_dims %2, %c1 : (!fir.box<!fir.array<?x?x?xf32>>, index) -> (index, index, index) |
| 1953 |
%17 = arith.cmpi sgt, %15#1, %c0 : index |
| 1954 |
%18 = arith.select %17, %15#1, %c0 : index |
| 1955 |
%19 = arith.cmpi sgt, %16#1, %c0 : index |
| 1956 |
%20 = arith.select %19, %16#1, %c0 : index |
| 1957 |
%21 = fir.load %8 : !fir.ref<i32> |
| 1958 |
%22 = fir.convert %21 : (i32) -> i64 |
| 1959 |
%23 = fir.undefined index |
| 1960 |
%24 = fir.slice %c1, %15#1, %c1, %c1, %16#1, %c1, %22, %23, %23 : (index, index, index, index, index, index, i64, index, index) -> !fir.slice<3> |
| 1961 |
%25 = fir.rebox %2 [%24] : (!fir.box<!fir.array<?x?x?xf32>>, !fir.slice<3>) -> !fir.box<!fir.array<?x?xf32>> |
| 1962 |
%26:3 = fir.box_dims %4, %c0 : (!fir.box<!fir.array<?x?x?x?xf32>>, index) -> (index, index, index) |
| 1963 |
%27:3 = fir.box_dims %4, %c1 : (!fir.box<!fir.array<?x?x?x?xf32>>, index) -> (index, index, index) |
| 1964 |
%28 = fir.slice %c1, %26#1, %c1, %c1, %27#1, %c1, %22, %23, %23, %22, %23, %23 : (index, index, index, index, index, index, i64, index, index, i64, index, index) -> !fir.slice<4> |
| 1965 |
%29 = fir.rebox %4 [%28] : (!fir.box<!fir.array<?x?x?x?xf32>>, !fir.slice<4>) -> !fir.box<!fir.array<?x?xf32>> |
| 1966 |
%30 = fir.do_loop %arg4 = %c1 to %20 step %c1 unordered iter_args(%arg5 = %cst) -> (f32) { |
| 1967 |
%35 = fir.do_loop %arg6 = %c1 to %18 step %c1 unordered iter_args(%arg7 = %arg5) -> (f32) { |
| 1968 |
%36 = fir.array_coor %25 %arg6, %arg4 : (!fir.box<!fir.array<?x?xf32>>, index, index) -> !fir.ref<f32> |
| 1969 |
%37 = fir.array_coor %29 %arg6, %arg4 : (!fir.box<!fir.array<?x?xf32>>, index, index) -> !fir.ref<f32> |
| 1970 |
%38 = fir.load %36 : !fir.ref<f32> |
| 1971 |
%39 = fir.load %37 : !fir.ref<f32> |
| 1972 |
%40 = arith.mulf %38, %39 fastmath<fast> : f32 |
| 1973 |
%41 = arith.addf %arg7, %40 fastmath<fast> : f32 |
| 1974 |
fir.result %41 : f32 |
| 1975 |
} |
| 1976 |
fir.result %35 : f32 |
| 1977 |
} |
| 1978 |
%31 = arith.addf %14, %30 fastmath<fast> : f32 |
| 1979 |
fir.store %31 to %10 : !fir.ref<f32> |
| 1980 |
%32 = arith.addi %arg2, %c1 overflow<nsw> : index |
| 1981 |
%33 = fir.load %8 : !fir.ref<i32> |
| 1982 |
%34 = arith.addi %33, %11 overflow<nsw> : i32 |
| 1983 |
fir.result %32, %34 : index, i32 |
| 1984 |
} |
| 1985 |
fir.store %12#1 to %8 : !fir.ref<i32> |
| 1986 |
%13 = fir.load %10 : !fir.ref<f32> |
| 1987 |
return %13 : f32 |
| 1988 |
} |
| 1989 |
// CHECK-LABEL: func.func @_QPtest_graphsimfct( |
| 1990 |
// CHECK: fir.do_loop |
| 1991 |
// CHECK: fir.do_loop |
| 1992 |
// CHECK: fir.if |
| 1993 |
// CHECK: fir.do_loop |
| 1994 |
// CHECK: } else { |
| 1995 |
// CHECK: fir.do_loop |
| 1996 |
|
| 1997 |
} // End module |