| 1 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=CHECK,CHECK-COMDAT,GENERIC |
| 2 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=CHECK,CHECK-COMDAT,GENERIC |
| 3 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=i386-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=CHECK,CHECK-COMDAT,GENERIC |
| 4 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=powerpc64le-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=CHECK,CHECK-COMDAT,GENERIC |
| 5 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=x86_64-pc-win32" %s | FileCheck %s --check-prefixes=CHECK,CHECK-COMDAT,GENERIC |
| 6 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=aarch64-apple-darwin" %s | FileCheck %s --check-prefixes=CHECK,CHECK-NO-COMDAT,GENERIC |
| 7 |
// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=amdgcn-amd-amdhsa, datalayout=e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-P0" %s | FileCheck -check-prefixes=CHECK,AMDGPU %s |
| 8 |
|
| 9 |
//=================================================== |
| 10 |
// SUMMARY: Tests for FIR --> LLVM MLIR conversion |
| 11 |
//=================================================== |
| 12 |
|
| 13 |
// Test simple global LLVM conversion |
| 14 |
|
| 15 |
fir.global @g_i0 : i32 { |
| 16 |
%1 = arith.constant 0 : i32 |
| 17 |
fir.has_value %1 : i32 |
| 18 |
} |
| 19 |
|
| 20 |
// CHECK: llvm.mlir.global external @g_i0() {addr_space = 0 : i32} : i32 { |
| 21 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 22 |
// CHECK: llvm.return %[[C0]] : i32 |
| 23 |
// CHECK: } |
| 24 |
|
| 25 |
// ----- |
| 26 |
|
| 27 |
fir.global @g_ci5 constant : i32 { |
| 28 |
%c = arith.constant 5 : i32 |
| 29 |
fir.has_value %c : i32 |
| 30 |
} |
| 31 |
|
| 32 |
// CHECK: llvm.mlir.global external constant @g_ci5() {addr_space = 0 : i32} : i32 { |
| 33 |
// CHECK: %[[C5:.*]] = llvm.mlir.constant(5 : i32) : i32 |
| 34 |
// CHECK: llvm.return %[[C5]] : i32 |
| 35 |
// CHECK: } |
| 36 |
|
| 37 |
// ----- |
| 38 |
|
| 39 |
fir.global internal @i_i515 (515:i32) : i32 |
| 40 |
// CHECK: llvm.mlir.global internal @i_i515(515 : i32) {addr_space = 0 : i32} : i32 |
| 41 |
|
| 42 |
// ----- |
| 43 |
|
| 44 |
fir.global common @C_i511 (0:i32) : i32 |
| 45 |
// CHECK: llvm.mlir.global common @C_i511(0 : i32) {addr_space = 0 : i32} : i32 |
| 46 |
|
| 47 |
// ----- |
| 48 |
|
| 49 |
fir.global weak @w_i86 (86:i32) : i32 |
| 50 |
// CHECK: llvm.mlir.global weak @w_i86(86 : i32) {addr_space = 0 : i32} : i32 |
| 51 |
|
| 52 |
// ----- |
| 53 |
|
| 54 |
fir.global linkonce @w_i86 (86:i32) : i32 |
| 55 |
// CHECK-COMDAT: llvm.mlir.global linkonce @w_i86(86 : i32) comdat(@__llvm_comdat::@w_i86) {addr_space = 0 : i32} : i32 |
| 56 |
// CHECK-NO-COMDAT: llvm.mlir.global linkonce @w_i86(86 : i32) {addr_space = 0 : i32} : i32 |
| 57 |
|
| 58 |
// ----- |
| 59 |
|
| 60 |
// Test conversion of fir.address_of with fir.global |
| 61 |
|
| 62 |
func.func @f1() { |
| 63 |
%0 = fir.address_of(@symbol) : !fir.ref<i64> |
| 64 |
return |
| 65 |
} |
| 66 |
|
| 67 |
fir.global @symbol : i64 { |
| 68 |
%0 = arith.constant 1 : i64 |
| 69 |
fir.has_value %0 : i64 |
| 70 |
} |
| 71 |
|
| 72 |
// CHECK: %{{.*}} = llvm.mlir.addressof @[[SYMBOL:.*]] : !llvm.ptr |
| 73 |
|
| 74 |
// CHECK: llvm.mlir.global external @[[SYMBOL]]() {addr_space = 0 : i32} : i64 { |
| 75 |
// CHECK: %{{.*}} = llvm.mlir.constant(1 : i64) : i64 |
| 76 |
// CHECK: llvm.return %{{.*}} : i64 |
| 77 |
// CHECK: } |
| 78 |
|
| 79 |
// ----- |
| 80 |
|
| 81 |
// Test global with insert_on_range operation covering the full array |
| 82 |
// in initializer region. |
| 83 |
|
| 84 |
fir.global internal @_QEmultiarray : !fir.array<32x32xi32> { |
| 85 |
%c0_i32 = arith.constant 1 : i32 |
| 86 |
%0 = fir.undefined !fir.array<32x32xi32> |
| 87 |
%2 = fir.insert_on_range %0, %c0_i32 from (0, 0) to (31, 31) : (!fir.array<32x32xi32>, i32) -> !fir.array<32x32xi32> |
| 88 |
fir.has_value %2 : !fir.array<32x32xi32> |
| 89 |
} |
| 90 |
|
| 91 |
// CHECK: llvm.mlir.global internal @_QEmultiarray() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x i32>> { |
| 92 |
// CHECK: %[[CST:.*]] = llvm.mlir.constant(dense<1> : vector<32x32xi32>) : !llvm.array<32 x array<32 x i32>> |
| 93 |
// CHECK: llvm.return %[[CST]] : !llvm.array<32 x array<32 x i32>> |
| 94 |
// CHECK: } |
| 95 |
|
| 96 |
// ----- |
| 97 |
|
| 98 |
// Test global with insert_on_range operation not covering the full array |
| 99 |
// in initializer region. |
| 100 |
|
| 101 |
fir.global internal @_QEmultiarray : !fir.array<32xi32> { |
| 102 |
%c0_i32 = arith.constant 1 : i32 |
| 103 |
%0 = fir.undefined !fir.array<32xi32> |
| 104 |
%2 = fir.insert_on_range %0, %c0_i32 from (5) to (31) : (!fir.array<32xi32>, i32) -> !fir.array<32xi32> |
| 105 |
fir.has_value %2 : !fir.array<32xi32> |
| 106 |
} |
| 107 |
|
| 108 |
// CHECK: llvm.mlir.global internal @_QEmultiarray() {addr_space = 0 : i32} : !llvm.array<32 x i32> { |
| 109 |
// CHECK: %[[CST:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 110 |
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.array<32 x i32> |
| 111 |
// CHECK: %{{.*}} = llvm.insertvalue %[[CST]], %{{.*}}[5] : !llvm.array<32 x i32> |
| 112 |
// CHECK-COUNT-24: %{{.*}} = llvm.insertvalue %[[CST]], %{{.*}}[{{.*}}] : !llvm.array<32 x i32> |
| 113 |
// CHECK: %{{.*}} = llvm.insertvalue %[[CST]], %{{.*}}[31] : !llvm.array<32 x i32> |
| 114 |
// CHECK-NOT: llvm.insertvalue |
| 115 |
// CHECK: llvm.return %{{.*}} : !llvm.array<32 x i32> |
| 116 |
// CHECK: } |
| 117 |
|
| 118 |
// ----- |
| 119 |
|
| 120 |
// Test global with box |
| 121 |
|
| 122 |
fir.global internal @_QFEx : !fir.box<!fir.ptr<i32>> { |
| 123 |
%0 = fir.zero_bits !fir.ptr<i32> |
| 124 |
%1 = fir.embox %0 : (!fir.ptr<i32>) -> !fir.box<!fir.ptr<i32>> |
| 125 |
fir.has_value %1 : !fir.box<!fir.ptr<i32>> |
| 126 |
} |
| 127 |
|
| 128 |
// CHECK-LABEL: llvm.mlir.global internal @_QFEx() |
| 129 |
// CHECK-SAME: !llvm.struct<([[DES_FIELDS:.*]])> |
| 130 |
// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.struct<([[DES_FIELDS]])> |
| 131 |
// CHECK: %[[T1:.*]] = llvm.insertvalue %{{.*}}, %[[T0]][1] : !llvm.struct<([[DES_FIELDS]])> |
| 132 |
// CHECK: %[[T2:.*]] = llvm.insertvalue %{{.*}}, %[[T1]][2] : !llvm.struct<([[DES_FIELDS]])> |
| 133 |
// CHECK: %[[T3:.*]] = llvm.insertvalue %{{.*}}, %[[T2]][3] : !llvm.struct<([[DES_FIELDS]])> |
| 134 |
// CHECK: %[[T4:.*]] = llvm.insertvalue %{{.*}}, %[[T3]][4] : !llvm.struct<([[DES_FIELDS]])> |
| 135 |
// CHECK: %[[T5:.*]] = llvm.insertvalue %{{.*}}, %[[T4]][5] : !llvm.struct<([[DES_FIELDS]])> |
| 136 |
// CHECK: %[[T6:.*]] = llvm.insertvalue %{{.*}}, %[[T5]][6] : !llvm.struct<([[DES_FIELDS]])> |
| 137 |
// CHECK: %[[GDES:.*]] = llvm.insertvalue %{{.*}}, %[[T6]][0] : !llvm.struct<([[DES_FIELDS]])> |
| 138 |
// CHECK: llvm.return %[[GDES]] : !llvm.struct<([[DES_FIELDS]])> |
| 139 |
|
| 140 |
// ----- |
| 141 |
|
| 142 |
// Test fir.zero_bits operation with LLVM ptr type |
| 143 |
|
| 144 |
func.func @zero_test_ptr() { |
| 145 |
%z = fir.zero_bits !llvm.ptr |
| 146 |
return |
| 147 |
} |
| 148 |
|
| 149 |
// CHECK: %{{.*}} = llvm.mlir.zero : !llvm.ptr |
| 150 |
// CHECK-NOT: fir.zero_bits |
| 151 |
|
| 152 |
// ----- |
| 153 |
|
| 154 |
// Test fir.zero_bits operation with integer type. |
| 155 |
|
| 156 |
func.func @zero_test_integer() { |
| 157 |
%z0 = fir.zero_bits i8 |
| 158 |
%z1 = fir.zero_bits i16 |
| 159 |
%z2 = fir.zero_bits i32 |
| 160 |
%z3 = fir.zero_bits i64 |
| 161 |
return |
| 162 |
} |
| 163 |
|
| 164 |
// CHECK: %{{.*}} = llvm.mlir.zero : i8 |
| 165 |
// CHECK: %{{.*}} = llvm.mlir.zero : i16 |
| 166 |
// CHECK: %{{.*}} = llvm.mlir.zero : i32 |
| 167 |
// CHECK: %{{.*}} = llvm.mlir.zero : i64 |
| 168 |
// CHECK-NOT: fir.zero_bits |
| 169 |
|
| 170 |
// ----- |
| 171 |
|
| 172 |
// Test fir.zero_bits operation with floating points types. |
| 173 |
|
| 174 |
func.func @zero_test_float() { |
| 175 |
%z0 = fir.zero_bits f16 |
| 176 |
%z1 = fir.zero_bits bf16 |
| 177 |
%z2 = fir.zero_bits f32 |
| 178 |
%z3 = fir.zero_bits f64 |
| 179 |
%z4 = fir.zero_bits f80 |
| 180 |
%z5 = fir.zero_bits f128 |
| 181 |
return |
| 182 |
} |
| 183 |
|
| 184 |
// CHECK: %{{.*}} = llvm.mlir.zero : f16 |
| 185 |
// CHECK: %{{.*}} = llvm.mlir.zero : bf16 |
| 186 |
// CHECK: %{{.*}} = llvm.mlir.zero : f32 |
| 187 |
// CHECK: %{{.*}} = llvm.mlir.zero : f64 |
| 188 |
// CHECK: %{{.*}} = llvm.mlir.zero : f80 |
| 189 |
// CHECK: %{{.*}} = llvm.mlir.zero : f128 |
| 190 |
// CHECK-NOT: fir.zero_bits |
| 191 |
|
| 192 |
// ----- |
| 193 |
|
| 194 |
// Test fir.zero_bits with aggregate types. |
| 195 |
|
| 196 |
func.func @zero_aggregate() { |
| 197 |
%a = fir.zero_bits !fir.array<10xf32> |
| 198 |
%b = fir.zero_bits !fir.type<a{i:i32,j:f32}> |
| 199 |
return |
| 200 |
} |
| 201 |
// CHECK: %{{.*}} = llvm.mlir.zero : !llvm.array<10 x f32> |
| 202 |
// CHECK: %{{.*}} = llvm.mlir.zero : !llvm.struct<"a", (i32, f32)> |
| 203 |
// CHECK-NOT: fir.zero_bits |
| 204 |
|
| 205 |
// ----- |
| 206 |
|
| 207 |
|
| 208 |
// Verify that fir.allocmem is transformed to a call to malloc |
| 209 |
// and that fir.freemem is transformed to a call to free |
| 210 |
// Single item case |
| 211 |
|
| 212 |
func.func @test_alloc_and_freemem_one() { |
| 213 |
%z0 = fir.allocmem i32 |
| 214 |
fir.freemem %z0 : !fir.heap<i32> |
| 215 |
return |
| 216 |
} |
| 217 |
|
| 218 |
// CHECK-LABEL: llvm.func @test_alloc_and_freemem_one() { |
| 219 |
// CHECK: %[[N:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 220 |
// CHECK-NEXT: llvm.call @malloc(%[[N]]) |
| 221 |
// CHECK: llvm.call @free(%{{.*}}) |
| 222 |
// CHECK-NEXT: llvm.return |
| 223 |
|
| 224 |
// ----- |
| 225 |
// Verify that fir.allocmem is transformed to a call to malloc |
| 226 |
// and that fir.freemem is transformed to a call to free |
| 227 |
// Several item case |
| 228 |
|
| 229 |
func.func @test_alloc_and_freemem_several() { |
| 230 |
%z0 = fir.allocmem !fir.array<100xf32> |
| 231 |
fir.freemem %z0 : !fir.heap<!fir.array<100xf32>> |
| 232 |
return |
| 233 |
} |
| 234 |
|
| 235 |
// CHECK-LABEL: llvm.func @test_alloc_and_freemem_several() { |
| 236 |
// CHECK: %[[N:.*]] = llvm.mlir.constant(400 : i64) : i64 |
| 237 |
// CHECK: [[MALLOC:%.*]] = llvm.call @malloc(%[[N]]) |
| 238 |
// CHECK: llvm.call @free([[MALLOC]]) |
| 239 |
// CHECK: llvm.return |
| 240 |
|
| 241 |
|
| 242 |
func.func @test_with_shape(%ncols: index, %nrows: index) { |
| 243 |
%1 = fir.allocmem !fir.array<?x?xf32>, %ncols, %nrows |
| 244 |
fir.freemem %1 : !fir.heap<!fir.array<?x?xf32>> |
| 245 |
return |
| 246 |
} |
| 247 |
|
| 248 |
// CHECK-LABEL: llvm.func @test_with_shape |
| 249 |
// CHECK-SAME: %[[NCOLS:.*]]: i64, %[[NROWS:.*]]: i64 |
| 250 |
// CHECK: %[[FOUR:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 251 |
// CHECK: %[[DIM1_SIZE:.*]] = llvm.mul %[[FOUR]], %[[NCOLS]] : i64 |
| 252 |
// CHECK: %[[TOTAL_SIZE:.*]] = llvm.mul %[[DIM1_SIZE]], %[[NROWS]] : i64 |
| 253 |
// CHECK: %[[MEM:.*]] = llvm.call @malloc(%[[TOTAL_SIZE]]) |
| 254 |
// CHECK: llvm.call @free(%[[MEM]]) : (!llvm.ptr) -> () |
| 255 |
// CHECK: llvm.return |
| 256 |
// CHECK: } |
| 257 |
|
| 258 |
func.func @test_string_with_shape(%len: index, %nelems: index) { |
| 259 |
%1 = fir.allocmem !fir.array<?x!fir.char<1,?>>(%len : index), %nelems |
| 260 |
fir.freemem %1 : !fir.heap<!fir.array<?x!fir.char<1,?>>> |
| 261 |
return |
| 262 |
} |
| 263 |
|
| 264 |
// CHECK-LABEL: llvm.func @test_string_with_shape |
| 265 |
// CHECK-SAME: %[[LEN:.*]]: i64, %[[NELEMS:.*]]: i64) |
| 266 |
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 267 |
// CHECK: %[[LEN_SIZE:.*]] = llvm.mul %[[ONE]], %[[LEN]] : i64 |
| 268 |
// CHECK: %[[TOTAL_SIZE:.*]] = llvm.mul %[[LEN_SIZE]], %[[NELEMS]] : i64 |
| 269 |
// CHECK: %[[MEM:.*]] = llvm.call @malloc(%[[TOTAL_SIZE]]) |
| 270 |
// CHECK: llvm.call @free(%[[MEM]]) : (!llvm.ptr) -> () |
| 271 |
// CHECK: llvm.return |
| 272 |
// CHECK: } |
| 273 |
|
| 274 |
// ----- |
| 275 |
|
| 276 |
// Verify that fir.unreachable is transformed to llvm.unreachable |
| 277 |
|
| 278 |
func.func @test_unreachable() { |
| 279 |
fir.unreachable |
| 280 |
} |
| 281 |
|
| 282 |
// CHECK: llvm.func @test_unreachable() { |
| 283 |
// CHECK-NEXT: llvm.unreachable |
| 284 |
// CHECK-NEXT: } |
| 285 |
|
| 286 |
// ----- |
| 287 |
|
| 288 |
// Test `fir.select` operation conversion pattern. |
| 289 |
// Check that the if-then-else ladder is correctly constructed and that we |
| 290 |
// branch to the correct block. |
| 291 |
|
| 292 |
func.func @select(%arg : index, %arg2 : i32) -> i32 { |
| 293 |
%0 = arith.constant 1 : i32 |
| 294 |
%1 = arith.constant 2 : i32 |
| 295 |
%2 = arith.constant 3 : i32 |
| 296 |
%3 = arith.constant 4 : i32 |
| 297 |
fir.select %arg:index [ 1, ^bb1(%0:i32), |
| 298 |
2, ^bb2(%2,%arg,%arg2:i32,index,i32), |
| 299 |
3, ^bb3(%arg2,%2:i32,i32), |
| 300 |
4, ^bb4(%1:i32), |
| 301 |
unit, ^bb5 ] |
| 302 |
^bb1(%a : i32) : |
| 303 |
return %a : i32 |
| 304 |
^bb2(%b : i32, %b2 : index, %b3:i32) : |
| 305 |
%castidx = arith.index_cast %b2 : index to i32 |
| 306 |
%4 = arith.addi %b, %castidx : i32 |
| 307 |
%5 = arith.addi %4, %b3 : i32 |
| 308 |
return %5 : i32 |
| 309 |
^bb3(%c:i32, %c2:i32) : |
| 310 |
%6 = arith.addi %c, %c2 : i32 |
| 311 |
return %6 : i32 |
| 312 |
^bb4(%d : i32) : |
| 313 |
return %d : i32 |
| 314 |
^bb5 : |
| 315 |
%zero = arith.constant 0 : i32 |
| 316 |
return %zero : i32 |
| 317 |
} |
| 318 |
|
| 319 |
// CHECK-LABEL: func @select( |
| 320 |
// CHECK-SAME: %[[SELECTVALUE:.*]]: [[IDX:.*]], |
| 321 |
// CHECK-SAME: %[[ARG1:.*]]: i32) |
| 322 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 323 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(2 : i32) : i32 |
| 324 |
// CHECK: %[[C2:.*]] = llvm.mlir.constant(3 : i32) : i32 |
| 325 |
// CHECK: %[[SELECTOR:.*]] = llvm.trunc %[[SELECTVALUE]] : i{{.*}} to i32 |
| 326 |
// CHECK: llvm.switch %[[SELECTOR]] : i32, ^bb5 [ |
| 327 |
// CHECK: 1: ^bb1(%[[C0]] : i32), |
| 328 |
// CHECK: 2: ^bb2(%[[C2]], %[[SELECTVALUE]], %[[ARG1]] : i32, [[IDX]], i32), |
| 329 |
// CHECK: 3: ^bb3(%[[ARG1]], %[[C2]] : i32, i32), |
| 330 |
// CHECK: 4: ^bb4(%[[C1]] : i32) |
| 331 |
// CHECK: ] |
| 332 |
|
| 333 |
// ----- |
| 334 |
|
| 335 |
// Test `fir.select_rank` operation conversion pattern. |
| 336 |
// Check that the if-then-else ladder is correctly constructed and that we |
| 337 |
// branch to the correct block. |
| 338 |
|
| 339 |
func.func @select_rank(%arg : i32, %arg2 : i32) -> i32 { |
| 340 |
%0 = arith.constant 1 : i32 |
| 341 |
%1 = arith.constant 2 : i32 |
| 342 |
%2 = arith.constant 3 : i32 |
| 343 |
%3 = arith.constant 4 : i32 |
| 344 |
fir.select_rank %arg:i32 [ 1, ^bb1(%0:i32), |
| 345 |
2, ^bb2(%2,%arg,%arg2:i32,i32,i32), |
| 346 |
3, ^bb3(%arg2,%2:i32,i32), |
| 347 |
4, ^bb4(%1:i32), |
| 348 |
unit, ^bb5 ] |
| 349 |
^bb1(%a : i32) : |
| 350 |
return %a : i32 |
| 351 |
^bb2(%b : i32, %b2 : i32, %b3:i32) : |
| 352 |
%4 = arith.addi %b, %b2 : i32 |
| 353 |
%5 = arith.addi %4, %b3 : i32 |
| 354 |
return %5 : i32 |
| 355 |
^bb3(%c:i32, %c2:i32) : |
| 356 |
%6 = arith.addi %c, %c2 : i32 |
| 357 |
return %6 : i32 |
| 358 |
^bb4(%d : i32) : |
| 359 |
return %d : i32 |
| 360 |
^bb5 : |
| 361 |
%zero = arith.constant 0 : i32 |
| 362 |
return %zero : i32 |
| 363 |
} |
| 364 |
|
| 365 |
// CHECK-LABEL: func @select_rank( |
| 366 |
// CHECK-SAME: %[[SELECTVALUE:.*]]: i32, |
| 367 |
// CHECK-SAME: %[[ARG1:.*]]: i32) |
| 368 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 369 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(2 : i32) : i32 |
| 370 |
// CHECK: %[[C2:.*]] = llvm.mlir.constant(3 : i32) : i32 |
| 371 |
// CHECK: llvm.switch %[[SELECTVALUE]] : i32, ^bb5 [ |
| 372 |
// CHECK: 1: ^bb1(%[[C0]] : i32), |
| 373 |
// CHECK: 2: ^bb2(%[[C2]], %[[SELECTVALUE]], %[[ARG1]] : i32, i32, i32), |
| 374 |
// CHECK: 3: ^bb3(%[[ARG1]], %[[C2]] : i32, i32), |
| 375 |
// CHECK: 4: ^bb4(%[[C1]] : i32) |
| 376 |
// CHECK: ] |
| 377 |
|
| 378 |
// ----- |
| 379 |
|
| 380 |
// Test fir.extract_value operation conversion with derived type. |
| 381 |
|
| 382 |
func.func @extract_derived_type() -> f32 { |
| 383 |
%0 = fir.undefined !fir.type<derived{f:f32}> |
| 384 |
%1 = fir.extract_value %0, ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>) -> f32 |
| 385 |
return %1 : f32 |
| 386 |
} |
| 387 |
|
| 388 |
// CHECK-LABEL: llvm.func @extract_derived_type |
| 389 |
// CHECK: %[[STRUCT:.*]] = llvm.mlir.undef : !llvm.struct<"derived", (f32)> |
| 390 |
// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0] : !llvm.struct<"derived", (f32)> |
| 391 |
// CHECK: llvm.return %[[VALUE]] : f32 |
| 392 |
|
| 393 |
// ----- |
| 394 |
|
| 395 |
// Test fir.extract_value operation conversion with a multi-dimensional array |
| 396 |
// of tuple. |
| 397 |
|
| 398 |
func.func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) -> f32 { |
| 399 |
%0 = fir.extract_value %a, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>) -> f32 |
| 400 |
return %0 : f32 |
| 401 |
} |
| 402 |
|
| 403 |
// CHECK-LABEL: llvm.func @extract_array( |
| 404 |
// CHECK-SAME: %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>> |
| 405 |
// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[ARR]][4, 5, 1] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> |
| 406 |
// CHECK: llvm.return %[[VALUE]] : f32 |
| 407 |
|
| 408 |
// ----- |
| 409 |
|
| 410 |
// Test fir.insert_value operation conversion with a multi-dimensional array |
| 411 |
// of tuple. |
| 412 |
|
| 413 |
func.func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) { |
| 414 |
%f = arith.constant 2.0 : f32 |
| 415 |
%i = arith.constant 1 : i32 |
| 416 |
%0 = fir.insert_value %a, %i, [5 : index, 4 : index, 0 : index] : (!fir.array<10x10xtuple<i32, f32>>, i32) -> !fir.array<10x10xtuple<i32, f32>> |
| 417 |
%1 = fir.insert_value %a, %f, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>, f32) -> !fir.array<10x10xtuple<i32, f32>> |
| 418 |
return |
| 419 |
} |
| 420 |
|
| 421 |
// CHECK-LABEL: llvm.func @extract_array( |
| 422 |
// CHECK-SAME: %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>> |
| 423 |
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4, 5, 0] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> |
| 424 |
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4, 5, 1] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> |
| 425 |
// CHECK: llvm.return |
| 426 |
|
| 427 |
// ----- |
| 428 |
|
| 429 |
// Test fir.insert_value operation conversion with derived type. |
| 430 |
|
| 431 |
func.func @insert_tuple(%a : tuple<i32, f32>) { |
| 432 |
%f = arith.constant 2.0 : f32 |
| 433 |
%1 = fir.insert_value %a, %f, [1 : index] : (tuple<i32, f32>, f32) -> tuple<i32, f32> |
| 434 |
return |
| 435 |
} |
| 436 |
|
| 437 |
// CHECK-LABEL: func @insert_tuple( |
| 438 |
// CHECK-SAME: %[[TUPLE:.*]]: !llvm.struct<(i32, f32)> |
| 439 |
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1] : !llvm.struct<(i32, f32)> |
| 440 |
// CHECK: llvm.return |
| 441 |
|
| 442 |
// ----- |
| 443 |
|
| 444 |
// Test `fir.call` -> `llvm.call` conversion for functions that take no arguments |
| 445 |
// and return nothing |
| 446 |
|
| 447 |
func.func @dummy_basic() { |
| 448 |
return |
| 449 |
} |
| 450 |
|
| 451 |
func.func @test_call_basic() { |
| 452 |
fir.call @dummy_basic() : () -> () |
| 453 |
return |
| 454 |
} |
| 455 |
|
| 456 |
// CHECK-LABEL: func @test_call_basic() { |
| 457 |
// CHECK-NEXT: llvm.call @dummy_basic() : () -> () |
| 458 |
// CHECK-NEXT: return |
| 459 |
// CHECK-NEXT: } |
| 460 |
|
| 461 |
// Test `fir.call` -> `llvm.call` conversion for functions that take one |
| 462 |
// argument and return nothing |
| 463 |
|
| 464 |
func.func @dummy_with_arg(%arg0 : i32) { |
| 465 |
return |
| 466 |
} |
| 467 |
|
| 468 |
func.func @test_call_with_arg(%arg0 : i32) { |
| 469 |
fir.call @dummy_with_arg(%arg0) : (i32) -> () |
| 470 |
return |
| 471 |
} |
| 472 |
|
| 473 |
// CHECK-LABEL: llvm.func @test_call_with_arg(%arg0: i32) { |
| 474 |
// CHECK-NEXT: llvm.call @dummy_with_arg(%arg0) : (i32) -> () |
| 475 |
// CHECK-NEXT: llvm.return |
| 476 |
// CHECK-NEXT: } |
| 477 |
|
| 478 |
// Test `fir.call` -> `llvm.call` conversion for functions that take no |
| 479 |
// arguments, but return a value |
| 480 |
|
| 481 |
func.func @dummy_return_val() -> i32 { |
| 482 |
%1 = arith.constant 123 : i32 |
| 483 |
return %1 : i32 |
| 484 |
} |
| 485 |
|
| 486 |
func.func @test_call_return_val() -> i32 { |
| 487 |
%1 = fir.call @dummy_return_val() : () -> (i32) |
| 488 |
return %1 : i32 |
| 489 |
} |
| 490 |
|
| 491 |
// CHECK-LABEL: llvm.func @test_call_return_val() -> i32 { |
| 492 |
// CHECK-NEXT: %0 = llvm.call @dummy_return_val() : () -> i32 |
| 493 |
// CHECK-NEXT: llvm.return %0 : i32 |
| 494 |
// CHECK-NEXT: } |
| 495 |
|
| 496 |
// ----- |
| 497 |
|
| 498 |
// Test FIR complex addition conversion |
| 499 |
// given: (x + iy) + (x' + iy') |
| 500 |
// result: (x + x') + i(y + y') |
| 501 |
|
| 502 |
func.func @fir_complex_add(%a: complex<f128>, %b: complex<f128>) -> complex<f128> { |
| 503 |
%c = fir.addc %a, %b {fastmath = #arith.fastmath<fast>} : complex<f128> |
| 504 |
return %c : complex<f128> |
| 505 |
} |
| 506 |
|
| 507 |
// CHECK-LABEL: llvm.func @fir_complex_add( |
| 508 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, |
| 509 |
// CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { |
| 510 |
// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> |
| 511 |
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> |
| 512 |
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> |
| 513 |
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> |
| 514 |
// CHECK: %[[ADD_X0_X1:.*]] = llvm.fadd %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 515 |
// CHECK: %[[ADD_Y0_Y1:.*]] = llvm.fadd %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 516 |
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> |
| 517 |
// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_X0_X1]], %{{.*}}[0] : !llvm.struct<(f128, f128)> |
| 518 |
// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_Y0_Y1]], %{{.*}}[1] : !llvm.struct<(f128, f128)> |
| 519 |
// CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> |
| 520 |
|
| 521 |
// ----- |
| 522 |
|
| 523 |
// Test FIR complex substraction conversion |
| 524 |
// given: (x + iy) - (x' + iy') |
| 525 |
// result: (x - x') + i(y - y') |
| 526 |
|
| 527 |
func.func @fir_complex_sub(%a: complex<f128>, %b: complex<f128>) -> complex<f128> { |
| 528 |
%c = fir.subc %a, %b {fastmath = #arith.fastmath<fast>} : complex<f128> |
| 529 |
return %c : complex<f128> |
| 530 |
} |
| 531 |
|
| 532 |
// CHECK-LABEL: llvm.func @fir_complex_sub( |
| 533 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, |
| 534 |
// CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { |
| 535 |
// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> |
| 536 |
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> |
| 537 |
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> |
| 538 |
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> |
| 539 |
// CHECK: %[[SUB_X0_X1:.*]] = llvm.fsub %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 540 |
// CHECK: %[[SUB_Y0_Y1:.*]] = llvm.fsub %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 541 |
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> |
| 542 |
// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_X0_X1]], %{{.*}}[0] : !llvm.struct<(f128, f128)> |
| 543 |
// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_Y0_Y1]], %{{.*}}[1] : !llvm.struct<(f128, f128)> |
| 544 |
// CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> |
| 545 |
|
| 546 |
// ----- |
| 547 |
|
| 548 |
// Test FIR complex multiply conversion |
| 549 |
// given: (x + iy) * (x' + iy') |
| 550 |
// result: (xx'-yy')+i(xy'+yx') |
| 551 |
|
| 552 |
func.func @fir_complex_mul(%a: complex<f128>, %b: complex<f128>) -> complex<f128> { |
| 553 |
%c = fir.mulc %a, %b {fastmath = #arith.fastmath<fast>} : complex<f128> |
| 554 |
return %c : complex<f128> |
| 555 |
} |
| 556 |
|
| 557 |
// CHECK-LABEL: llvm.func @fir_complex_mul( |
| 558 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, |
| 559 |
// CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { |
| 560 |
// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> |
| 561 |
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> |
| 562 |
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> |
| 563 |
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> |
| 564 |
// CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 565 |
// CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 566 |
// CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 567 |
// CHECK: %[[ADD:.*]] = llvm.fadd %[[MUL_X0_Y1]], %[[MUL_Y0_X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 568 |
// CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 569 |
// CHECK: %[[SUB:.*]] = llvm.fsub %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 570 |
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> |
| 571 |
// CHECK: %{{.*}} = llvm.insertvalue %[[SUB]], %{{.*}}[0] : !llvm.struct<(f128, f128)> |
| 572 |
// CHECK: %{{.*}} = llvm.insertvalue %[[ADD]], %{{.*}}[1] : !llvm.struct<(f128, f128)> |
| 573 |
// CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> |
| 574 |
|
| 575 |
// ----- |
| 576 |
|
| 577 |
// Test FIR complex division conversion |
| 578 |
// given: (x + iy) / (x' + iy') |
| 579 |
// result: ((xx'+yy')/d) + i((yx'-xy')/d) where d = x'x' + y'y' |
| 580 |
|
| 581 |
func.func @fir_complex_div(%a: complex<f128>, %b: complex<f128>) -> complex<f128> { |
| 582 |
%c = fir.divc %a, %b {fastmath = #arith.fastmath<fast>} : complex<f128> |
| 583 |
return %c : complex<f128> |
| 584 |
} |
| 585 |
|
| 586 |
// CHECK-LABEL: llvm.func @fir_complex_div( |
| 587 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, |
| 588 |
// CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { |
| 589 |
// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> |
| 590 |
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> |
| 591 |
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> |
| 592 |
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> |
| 593 |
// CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 594 |
// CHECK: %[[MUL_X1_X1:.*]] = llvm.fmul %[[X1]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 595 |
// CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 596 |
// CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 597 |
// CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 598 |
// CHECK: %[[MUL_Y1_Y1:.*]] = llvm.fmul %[[Y1]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 599 |
// CHECK: %[[ADD_X1X1_Y1Y1:.*]] = llvm.fadd %[[MUL_X1_X1]], %[[MUL_Y1_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 600 |
// CHECK: %[[ADD_X0X1_Y0Y1:.*]] = llvm.fadd %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 601 |
// CHECK: %[[SUB_Y0X1_X0Y1:.*]] = llvm.fsub %[[MUL_Y0_X1]], %[[MUL_X0_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 602 |
// CHECK: %[[DIV0:.*]] = llvm.fdiv %[[ADD_X0X1_Y0Y1]], %[[ADD_X1X1_Y1Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 603 |
// CHECK: %[[DIV1:.*]] = llvm.fdiv %[[SUB_Y0X1_X0Y1]], %[[ADD_X1X1_Y1Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128 |
| 604 |
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> |
| 605 |
// CHECK: %{{.*}} = llvm.insertvalue %[[DIV0]], %{{.*}}[0] : !llvm.struct<(f128, f128)> |
| 606 |
// CHECK: %{{.*}} = llvm.insertvalue %[[DIV1]], %{{.*}}[1] : !llvm.struct<(f128, f128)> |
| 607 |
// CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> |
| 608 |
|
| 609 |
// ----- |
| 610 |
|
| 611 |
// Test FIR complex negation conversion |
| 612 |
// given: -(x + iy) |
| 613 |
// result: -x - iy |
| 614 |
|
| 615 |
func.func @fir_complex_neg(%a: complex<f128>) -> complex<f128> { |
| 616 |
%c = fir.negc %a : complex<f128> |
| 617 |
return %c : complex<f128> |
| 618 |
} |
| 619 |
|
| 620 |
// CHECK-LABEL: llvm.func @fir_complex_neg( |
| 621 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { |
| 622 |
// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> |
| 623 |
// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> |
| 624 |
// CHECK: %[[NEGX:.*]] = llvm.fneg %[[X]] : f128 |
| 625 |
// CHECK: %[[NEGY:.*]] = llvm.fneg %[[Y]] : f128 |
| 626 |
// CHECK: %{{.*}} = llvm.insertvalue %[[NEGX]], %{{.*}}[0] : !llvm.struct<(f128, f128)> |
| 627 |
// CHECK: %{{.*}} = llvm.insertvalue %[[NEGY]], %{{.*}}[1] : !llvm.struct<(f128, f128)> |
| 628 |
// CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> |
| 629 |
|
| 630 |
// ----- |
| 631 |
|
| 632 |
// Test FIR complex compare conversion |
| 633 |
|
| 634 |
func.func @compare_complex_eq(%a : complex<f64>, %b : complex<f64>) -> i1 { |
| 635 |
%r = fir.cmpc "oeq", %a, %b : complex<f64> |
| 636 |
return %r : i1 |
| 637 |
} |
| 638 |
|
| 639 |
// CHECK-LABEL: llvm.func @compare_complex_eq |
| 640 |
// CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>, |
| 641 |
// CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)> |
| 642 |
// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0] : !llvm.struct<(f64, f64)> |
| 643 |
// CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1] : !llvm.struct<(f64, f64)> |
| 644 |
// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0] : !llvm.struct<(f64, f64)> |
| 645 |
// CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1] : !llvm.struct<(f64, f64)> |
| 646 |
// CHECK-DAG: [[RESR:%.*]] = llvm.fcmp "oeq" [[RA]], [[RB]] : f64 |
| 647 |
// CHECK-DAG: [[RESI:%.*]] = llvm.fcmp "oeq" [[IA]], [[IB]] : f64 |
| 648 |
// CHECK: [[RES:%.*]] = llvm.and [[RESR]], [[RESI]] : i1 |
| 649 |
// CHECK: return [[RES]] : i1 |
| 650 |
|
| 651 |
func.func @compare_complex_ne(%a : complex<f64>, %b : complex<f64>) -> i1 { |
| 652 |
%r = fir.cmpc "une", %a, %b {fastmath = #arith.fastmath<fast>} : complex<f64> |
| 653 |
return %r : i1 |
| 654 |
} |
| 655 |
|
| 656 |
// CHECK-LABEL: llvm.func @compare_complex_ne |
| 657 |
// CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>, |
| 658 |
// CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)> |
| 659 |
// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0] : !llvm.struct<(f64, f64)> |
| 660 |
// CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1] : !llvm.struct<(f64, f64)> |
| 661 |
// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0] : !llvm.struct<(f64, f64)> |
| 662 |
// CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1] : !llvm.struct<(f64, f64)> |
| 663 |
// CHECK-DAG: [[RESR:%.*]] = llvm.fcmp "une" [[RA]], [[RB]] {fastmathFlags = #llvm.fastmath<fast>} : f64 |
| 664 |
// CHECK-DAG: [[RESI:%.*]] = llvm.fcmp "une" [[IA]], [[IB]] {fastmathFlags = #llvm.fastmath<fast>} : f64 |
| 665 |
// CHECK: [[RES:%.*]] = llvm.or [[RESR]], [[RESI]] : i1 |
| 666 |
// CHECK: return [[RES]] : i1 |
| 667 |
|
| 668 |
func.func @compare_complex_other(%a : complex<f64>, %b : complex<f64>) -> i1 { |
| 669 |
%r = fir.cmpc "ogt", %a, %b {fastmath = #arith.fastmath<fast>} : complex<f64> |
| 670 |
return %r : i1 |
| 671 |
} |
| 672 |
|
| 673 |
// CHECK-LABEL: llvm.func @compare_complex_other |
| 674 |
// CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>, |
| 675 |
// CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)> |
| 676 |
// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0] : !llvm.struct<(f64, f64)> |
| 677 |
// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0] : !llvm.struct<(f64, f64)> |
| 678 |
// CHECK: [[RESR:%.*]] = llvm.fcmp "ogt" [[RA]], [[RB]] {fastmathFlags = #llvm.fastmath<fast>} : f64 |
| 679 |
// CHECK: return [[RESR]] : i1 |
| 680 |
|
| 681 |
// ----- |
| 682 |
|
| 683 |
// Test `fir.convert` operation conversion from Float type. |
| 684 |
|
| 685 |
func.func @convert_from_float(%arg0 : f32) { |
| 686 |
%0 = fir.convert %arg0 : (f32) -> f16 |
| 687 |
%1 = fir.convert %arg0 : (f32) -> f32 |
| 688 |
%2 = fir.convert %arg0 : (f32) -> f64 |
| 689 |
%3 = fir.convert %arg0 : (f32) -> f80 |
| 690 |
%4 = fir.convert %arg0 : (f32) -> f128 |
| 691 |
%5 = fir.convert %arg0 : (f32) -> i1 |
| 692 |
%6 = fir.convert %arg0 : (f32) -> i8 |
| 693 |
%7 = fir.convert %arg0 : (f32) -> i16 |
| 694 |
%8 = fir.convert %arg0 : (f32) -> i32 |
| 695 |
%9 = fir.convert %arg0 : (f32) -> i64 |
| 696 |
%10 = fir.convert %arg0 : (f32) -> ui8 |
| 697 |
%11 = fir.convert %arg0 : (f32) -> ui16 |
| 698 |
%12 = fir.convert %arg0 : (f32) -> ui32 |
| 699 |
%13 = fir.convert %arg0 : (f32) -> ui64 |
| 700 |
return |
| 701 |
} |
| 702 |
|
| 703 |
// CHECK-LABEL: convert_from_float( |
| 704 |
// CHECK-SAME: %[[ARG0:.*]]: f32 |
| 705 |
// CHECK: %{{.*}} = llvm.fptrunc %[[ARG0]] : f32 to f16 |
| 706 |
// CHECK-NOT: f32 to f32 |
| 707 |
// CHECK: %{{.*}} = llvm.fpext %[[ARG0]] : f32 to f64 |
| 708 |
// CHECK: %{{.*}} = llvm.fpext %[[ARG0]] : f32 to f80 |
| 709 |
// CHECK: %{{.*}} = llvm.fpext %[[ARG0]] : f32 to f128 |
| 710 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptosi.sat"(%[[ARG0]]) : (f32) -> i1 |
| 711 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptosi.sat"(%[[ARG0]]) : (f32) -> i8 |
| 712 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptosi.sat"(%[[ARG0]]) : (f32) -> i16 |
| 713 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptosi.sat"(%[[ARG0]]) : (f32) -> i32 |
| 714 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptosi.sat"(%[[ARG0]]) : (f32) -> i64 |
| 715 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptoui.sat"(%[[ARG0]]) : (f32) -> i8 |
| 716 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptoui.sat"(%[[ARG0]]) : (f32) -> i16 |
| 717 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptoui.sat"(%[[ARG0]]) : (f32) -> i32 |
| 718 |
// CHECK: %{{.*}} = llvm.call_intrinsic "llvm.fptoui.sat"(%[[ARG0]]) : (f32) -> i64 |
| 719 |
|
| 720 |
// ----- |
| 721 |
|
| 722 |
// Test `fir.convert` operation conversion from Integer type. |
| 723 |
|
| 724 |
func.func @convert_from_int(%arg0 : i32) { |
| 725 |
%0 = fir.convert %arg0 : (i32) -> f16 |
| 726 |
%1 = fir.convert %arg0 : (i32) -> f32 |
| 727 |
%2 = fir.convert %arg0 : (i32) -> f64 |
| 728 |
%3 = fir.convert %arg0 : (i32) -> f80 |
| 729 |
%4 = fir.convert %arg0 : (i32) -> f128 |
| 730 |
%5 = fir.convert %arg0 : (i32) -> i1 |
| 731 |
%6 = fir.convert %arg0 : (i32) -> i8 |
| 732 |
%7 = fir.convert %arg0 : (i32) -> i16 |
| 733 |
%8 = fir.convert %arg0 : (i32) -> i32 |
| 734 |
%9 = fir.convert %arg0 : (i32) -> i64 |
| 735 |
%10 = fir.convert %arg0 : (i32) -> i64 |
| 736 |
%ptr = fir.convert %10 : (i64) -> !fir.ref<i64> |
| 737 |
return |
| 738 |
} |
| 739 |
|
| 740 |
// CHECK-LABEL: convert_from_int( |
| 741 |
// CHECK-SAME: %[[ARG0:.*]]: i32 |
| 742 |
// CHECK: %{{.*}} = llvm.sitofp %[[ARG0]] : i32 to f16 |
| 743 |
// CHECK: %{{.*}} = llvm.sitofp %[[ARG0]] : i32 to f32 |
| 744 |
// CHECK: %{{.*}} = llvm.sitofp %[[ARG0]] : i32 to f64 |
| 745 |
// CHECK: %{{.*}} = llvm.sitofp %[[ARG0]] : i32 to f80 |
| 746 |
// CHECK: %{{.*}} = llvm.sitofp %[[ARG0]] : i32 to f128 |
| 747 |
// CHECK: %{{.*}} = llvm.trunc %[[ARG0]] : i32 to i1 |
| 748 |
// CHECK: %{{.*}} = llvm.trunc %[[ARG0]] : i32 to i8 |
| 749 |
// CHECK: %{{.*}} = llvm.trunc %[[ARG0]] : i32 to i16 |
| 750 |
// CHECK-NOT: %{{.*}} = llvm.trunc %[[ARG0]] : i32 to i32 |
| 751 |
// CHECK: %{{.*}} = llvm.sext %[[ARG0]] : i32 to i64 |
| 752 |
// CHECK: %{{.*}} = llvm.inttoptr %{{.*}} : i64 to !llvm.ptr |
| 753 |
|
| 754 |
|
| 755 |
func.func @convert_from_i1(%arg0 : i1) { |
| 756 |
%0 = fir.convert %arg0 : (i1) -> i32 |
| 757 |
return |
| 758 |
} |
| 759 |
|
| 760 |
// CHECK-LABEL: convert_from_i1( |
| 761 |
// CHECK-SAME: %[[ARG0:.*]]: i1 |
| 762 |
// CHECK: %{{.*}} = llvm.zext %[[ARG0]] : i1 to i32 |
| 763 |
|
| 764 |
// ----- |
| 765 |
|
| 766 |
// Test `fir.convert` operation conversion from !fir.ref<> type. |
| 767 |
|
| 768 |
func.func @convert_from_ref(%arg0 : !fir.ref<i32>) { |
| 769 |
%0 = fir.convert %arg0 : (!fir.ref<i32>) -> !fir.ref<i8> |
| 770 |
%1 = fir.convert %arg0 : (!fir.ref<i32>) -> i32 |
| 771 |
return |
| 772 |
} |
| 773 |
|
| 774 |
// CHECK-LABEL: convert_from_ref( |
| 775 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 776 |
// CHECK-NOT: %{{.*}} = llvm.bitcast %[[ARG0]] : !llvm.ptr to !llvm.ptr |
| 777 |
// CHECK: %{{.*}} = llvm.ptrtoint %[[ARG0]] : !llvm.ptr to i32 |
| 778 |
|
| 779 |
// ----- |
| 780 |
|
| 781 |
// Test `fir.convert` operation conversion between fir.complex types. |
| 782 |
|
| 783 |
func.func @convert_complex4(%arg0 : complex<f32>) -> complex<f64> { |
| 784 |
%0 = fir.convert %arg0 : (complex<f32>) -> complex<f64> |
| 785 |
return %0 : complex<f64> |
| 786 |
} |
| 787 |
|
| 788 |
// CHECK-LABEL: func @convert_complex4( |
| 789 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f32, f32)>) -> !llvm.struct<(f64, f64)> |
| 790 |
// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f32, f32)> |
| 791 |
// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f32, f32)> |
| 792 |
// CHECK: %[[CONVERTX:.*]] = llvm.fpext %[[X]] : f32 to f64 |
| 793 |
// CHECK: %[[CONVERTY:.*]] = llvm.fpext %[[Y]] : f32 to f64 |
| 794 |
// CHECK: %[[STRUCT0:.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)> |
| 795 |
// CHECK: %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0] : !llvm.struct<(f64, f64)> |
| 796 |
// CHECK: %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1] : !llvm.struct<(f64, f64)> |
| 797 |
// CHECK: llvm.return %[[STRUCT2]] : !llvm.struct<(f64, f64)> |
| 798 |
|
| 799 |
// Test `fir.convert` operation conversion between fir.complex types. |
| 800 |
|
| 801 |
func.func @convert_complex16(%arg0 : complex<f128>) -> complex<f16> { |
| 802 |
%0 = fir.convert %arg0 : (complex<f128>) -> complex<f16> |
| 803 |
return %0 : complex<f16> |
| 804 |
} |
| 805 |
|
| 806 |
// CHECK-LABEL: func @convert_complex16( |
| 807 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f16, f16)> |
| 808 |
// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> |
| 809 |
// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> |
| 810 |
// CHECK: %[[CONVERTX:.*]] = llvm.fptrunc %[[X]] : f128 to f16 |
| 811 |
// CHECK: %[[CONVERTY:.*]] = llvm.fptrunc %[[Y]] : f128 to f16 |
| 812 |
// CHECK: %[[STRUCT0:.*]] = llvm.mlir.undef : !llvm.struct<(f16, f16)> |
| 813 |
// CHECK: %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0] : !llvm.struct<(f16, f16)> |
| 814 |
// CHECK: %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1] : !llvm.struct<(f16, f16)> |
| 815 |
// CHECK: llvm.return %[[STRUCT2]] : !llvm.struct<(f16, f16)> |
| 816 |
|
| 817 |
// ----- |
| 818 |
|
| 819 |
// Test `fir.convert` operation conversion between compatible fir.record types. |
| 820 |
|
| 821 |
func.func @convert_record(%arg0 : !fir.type<_QMmod1Trec{i:i32,f:f64,c:!llvm.struct<(f32, f32)>,cstr:!fir.array<4x!fir.char<1>>}>) -> |
| 822 |
!fir.type<_QMmod2Trec{i:i32,f:f64,c:!llvm.struct<(f32, f32)>,cstr:!fir.array<4x!fir.char<1>>}> { |
| 823 |
%0 = fir.convert %arg0 : (!fir.type<_QMmod1Trec{i:i32,f:f64,c:!llvm.struct<(f32, f32)>,cstr:!fir.array<4x!fir.char<1>>}>) -> |
| 824 |
!fir.type<_QMmod2Trec{i:i32,f:f64,c:!llvm.struct<(f32, f32)>,cstr:!fir.array<4x!fir.char<1>>}> |
| 825 |
return %0 : !fir.type<_QMmod2Trec{i:i32,f:f64,c:!llvm.struct<(f32, f32)>,cstr:!fir.array<4x!fir.char<1>>}> |
| 826 |
} |
| 827 |
|
| 828 |
// CHECK-LABEL: func @convert_record( |
| 829 |
// CHECK-SAME: %[[ARG0:.*]]: [[MOD1_REC:!llvm.struct<"_QMmod1Trec", \(i32, f64, struct<\(f32, f32\)>, array<4 x array<1 x i8>>\)>]]) -> |
| 830 |
// CHECK-SAME: [[MOD2_REC:!llvm.struct<"_QMmod2Trec", \(i32, f64, struct<\(f32, f32\)>, array<4 x array<1 x i8>>\)>]] |
| 831 |
// CHECK: %{{.*}} = llvm.mlir.undef : [[MOD2_REC]] |
| 832 |
// CHECK-DAG: %[[I:.*]] = llvm.extractvalue %[[ARG0]][0] : [[MOD1_REC]] |
| 833 |
// CHECK-DAG: %{{.*}} = llvm.insertvalue %[[I]], %{{.*}}[0] : [[MOD2_REC]] |
| 834 |
// CHECK-DAG: %[[F:.*]] = llvm.extractvalue %[[ARG0]][1] : [[MOD1_REC]] |
| 835 |
// CHECK-DAG: %{{.*}} = llvm.insertvalue %[[F]], %{{.*}}[1] : [[MOD2_REC]] |
| 836 |
// CHECK-DAG: %[[C:.*]] = llvm.extractvalue %[[ARG0]][2] : [[MOD1_REC]] |
| 837 |
// CHECK-DAG: %{{.*}} = llvm.insertvalue %[[C]], %{{.*}}[2] : [[MOD2_REC]] |
| 838 |
// CHECK-DAG: %[[CSTR:.*]] = llvm.extractvalue %[[ARG0]][3] : [[MOD1_REC]] |
| 839 |
// CHECK-DAG: %{{.*}} = llvm.insertvalue %[[CSTR]], %{{.*}}[3] : [[MOD2_REC]] |
| 840 |
// CHECK: llvm.return %{{.*}} : [[MOD2_REC]] |
| 841 |
|
| 842 |
// ----- |
| 843 |
|
| 844 |
// Test `fir.store` --> `llvm.store` conversion |
| 845 |
|
| 846 |
func.func @test_store_index(%val_to_store : index, %addr : !fir.ref<index>) { |
| 847 |
fir.store %val_to_store to %addr : !fir.ref<index> |
| 848 |
return |
| 849 |
} |
| 850 |
|
| 851 |
// CHECK-LABEL: llvm.func @test_store_index |
| 852 |
// CHECK-SAME: (%[[arg0:.*]]: i64, %[[arg1:.*]]: !llvm.ptr) { |
| 853 |
// CHECK-NEXT: llvm.store %[[arg0]], %[[arg1]] : i64, !llvm.ptr |
| 854 |
// CHECK-NEXT: llvm.return |
| 855 |
// CHECK-NEXT: } |
| 856 |
|
| 857 |
func.func @test_store_box(%array : !fir.ref<!fir.box<!fir.array<?x?xf32>>>, %box : !fir.box<!fir.array<?x?xf32>>) { |
| 858 |
fir.store %box to %array : !fir.ref<!fir.box<!fir.array<?x?xf32>>> |
| 859 |
return |
| 860 |
} |
| 861 |
|
| 862 |
// CHECK-LABEL: llvm.func @test_store_box |
| 863 |
// CHECK-SAME: (%[[arg0:.*]]: !llvm.ptr, |
| 864 |
// CHECK-SAME: %[[arg1:.*]]: !llvm.ptr) { |
| 865 |
// CHECK-NEXT: %[[size:.*]] = llvm.mlir.constant(72 : i32) : i32 |
| 866 |
// CHECK-NEXT: "llvm.intr.memcpy"(%[[arg0]], %[[arg1]], %[[size]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 867 |
// CHECK-NEXT: llvm.return |
| 868 |
// CHECK-NEXT: } |
| 869 |
|
| 870 |
|
| 871 |
func.func @store_unlimited_polymorphic_box(%arg0 : !fir.class<none>, %arg1 : !fir.class<!fir.array<?xnone>>, %arg2 : !fir.box<none>, %arg3 : !fir.box<!fir.array<?xnone>>, %arg0r : !fir.ref<!fir.class<none>>, %arg1r : !fir.ref<!fir.class<!fir.array<?xnone>>>, %arg2r : !fir.ref<!fir.box<none>>, %arg3r : !fir.ref<!fir.box<!fir.array<?xnone>>>) { |
| 872 |
fir.store %arg0 to %arg0r : !fir.ref<!fir.class<none>> |
| 873 |
fir.store %arg1 to %arg1r : !fir.ref<!fir.class<!fir.array<?xnone>>> |
| 874 |
fir.store %arg2 to %arg2r : !fir.ref<!fir.box<none>> |
| 875 |
fir.store %arg3 to %arg3r : !fir.ref<!fir.box<!fir.array<?xnone>>> |
| 876 |
return |
| 877 |
} |
| 878 |
// CHECK: llvm.func @store_unlimited_polymorphic_box(%[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: !llvm.ptr, %[[VAL_2:.*]]: !llvm.ptr, %[[VAL_3:.*]]: !llvm.ptr, %[[VAL_4:.*]]: !llvm.ptr, %[[VAL_5:.*]]: !llvm.ptr, %[[VAL_6:.*]]: !llvm.ptr, %[[VAL_7:.*]]: !llvm.ptr) { |
| 879 |
// CHECK: %[[VAL_8:.*]] = llvm.mlir.constant(40 : i32) : i32 |
| 880 |
// CHECK: "llvm.intr.memcpy"(%[[VAL_4]], %[[VAL_0]], %[[VAL_8]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 881 |
// CHECK: %[[VAL_9:.*]] = llvm.mlir.constant(64 : i32) : i32 |
| 882 |
// CHECK: "llvm.intr.memcpy"(%[[VAL_5]], %[[VAL_1]], %[[VAL_9]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 883 |
// CHECK: %[[VAL_10:.*]] = llvm.mlir.constant(40 : i32) : i32 |
| 884 |
// CHECK: "llvm.intr.memcpy"(%[[VAL_6]], %[[VAL_2]], %[[VAL_10]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 885 |
// CHECK: %[[VAL_11:.*]] = llvm.mlir.constant(64 : i32) : i32 |
| 886 |
// CHECK: "llvm.intr.memcpy"(%[[VAL_7]], %[[VAL_3]], %[[VAL_11]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 887 |
// CHECK: llvm.return |
| 888 |
// CHECK: } |
| 889 |
|
| 890 |
|
| 891 |
// ----- |
| 892 |
|
| 893 |
func.func @store_assumed_rank_box(%box: !fir.box<!fir.array<*:f32>>, %ref: !fir.ref<!fir.box<!fir.array<*:f32>>>) { |
| 894 |
fir.store %box to %ref : !fir.ref<!fir.box<!fir.array<*:f32>>> |
| 895 |
return |
| 896 |
} |
| 897 |
|
| 898 |
// CHECK-LABEL: llvm.func @store_assumed_rank_box( |
| 899 |
// CHECK-SAME: %[[VAL_0:[^:]*]]: !llvm.ptr, |
| 900 |
// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) { |
| 901 |
// CHECK: %[[VAL_2:.*]] = llvm.mlir.constant(24 : i32) : i32 |
| 902 |
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> |
| 903 |
// CHECK: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i8 |
| 904 |
// CHECK: %[[VAL_5:.*]] = llvm.sext %[[VAL_4]] : i8 to i32 |
| 905 |
// CHECK: %[[VAL_6:.*]] = llvm.mlir.constant(24 : i32) : i32 |
| 906 |
// CHECK: %[[VAL_7:.*]] = llvm.mul %[[VAL_6]], %[[VAL_5]] : i32 |
| 907 |
// CHECK: %[[VAL_8:.*]] = llvm.add %[[VAL_2]], %[[VAL_7]] : i32 |
| 908 |
// CHECK: "llvm.intr.memcpy"(%[[VAL_1]], %[[VAL_0]], %[[VAL_8]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 909 |
|
| 910 |
// ----- |
| 911 |
|
| 912 |
// Test `fir.load` --> `llvm.load` conversion |
| 913 |
|
| 914 |
func.func @test_load_index(%addr : !fir.ref<index>) { |
| 915 |
%0 = fir.load %addr : !fir.ref<index> |
| 916 |
return |
| 917 |
} |
| 918 |
|
| 919 |
// CHECK-LABEL: llvm.func @test_load_index( |
| 920 |
// CHECK-SAME: %[[arg1:.*]]: !llvm.ptr) { |
| 921 |
// CHECK-NEXT: %0 = llvm.load %[[arg1]] : !llvm.ptr -> i64 |
| 922 |
// CHECK-NEXT: llvm.return |
| 923 |
// CHECK-NEXT: } |
| 924 |
|
| 925 |
func.func private @takes_box(!fir.box<!fir.array<10xf32>>) -> () |
| 926 |
|
| 927 |
func.func @test_load_box(%addr : !fir.ref<!fir.box<!fir.array<10xf32>>>) { |
| 928 |
%0 = fir.load %addr : !fir.ref<!fir.box<!fir.array<10xf32>>> |
| 929 |
fir.call @takes_box(%0) : (!fir.box<!fir.array<10xf32>>) -> () |
| 930 |
return |
| 931 |
} |
| 932 |
|
| 933 |
// Loading a `fir.ref<!fir.box>> is creating a descriptor copy |
| 934 |
// CHECK-LABEL: llvm.func @test_load_box( |
| 935 |
// CHECK-SAME: %[[arg0:.*]]: !llvm.ptr) { |
| 936 |
// CHECK-NEXT: %[[c1:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 937 |
// GENERIC-NEXT: %[[box_copy:.*]] = llvm.alloca %[[c1]] x !llvm.struct<([[DESC_TYPE:.*]])> |
| 938 |
// AMDGPU-NEXT: %[[alloca_box_copy:.*]] = llvm.alloca %[[c1]] x !llvm.struct<([[DESC_TYPE:.*]])>{{.*}} : (i32) -> !llvm.ptr<5> |
| 939 |
// AMDGPU-NEXT: %[[box_copy:.*]] = llvm.addrspacecast %[[alloca_box_copy]] : !llvm.ptr<5> to !llvm.ptr |
| 940 |
// CHECK-NEXT: %[[size:.*]] = llvm.mlir.constant(48 : i32) : i32 |
| 941 |
// CHECK-NEXT: "llvm.intr.memcpy"(%[[box_copy]], %[[arg0]], %[[size]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 942 |
// CHECK-NEXT: llvm.call @takes_box(%[[box_copy]]) : (!llvm.ptr) -> () |
| 943 |
// CHECK-NEXT: llvm.return |
| 944 |
// CHECK-NEXT: } |
| 945 |
|
| 946 |
// ----- |
| 947 |
|
| 948 |
func.func @test_assumed_rank_load(%arg0: !fir.ref<!fir.box<!fir.array<*:f64>>>) -> () { |
| 949 |
%0 = fir.load %arg0 : !fir.ref<!fir.box<!fir.array<*:f64>>> |
| 950 |
fir.call @some_assumed_rank_func(%0) : (!fir.box<!fir.array<*:f64>>) -> () |
| 951 |
return |
| 952 |
} |
| 953 |
func.func private @some_assumed_rank_func(!fir.box<!fir.array<*:f64>>) -> () |
| 954 |
|
| 955 |
// CHECK-LABEL: llvm.func @test_assumed_rank_load( |
| 956 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) { |
| 957 |
// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 958 |
// GENERIC: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 959 |
// AMDGPU: %[[VAL_2A:.*]] = llvm.alloca %[[VAL_1]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 960 |
// AMDGPU: %[[VAL_2:.*]] = llvm.addrspacecast %[[VAL_2A]] : !llvm.ptr<5> to !llvm.ptr |
| 961 |
// CHECK: %[[VAL_3:.*]] = llvm.mlir.constant(24 : i32) : i32 |
| 962 |
// CHECK: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> |
| 963 |
// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] : !llvm.ptr -> i8 |
| 964 |
// CHECK: %[[VAL_6:.*]] = llvm.sext %[[VAL_5]] : i8 to i32 |
| 965 |
// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(24 : i32) : i32 |
| 966 |
// CHECK: %[[VAL_8:.*]] = llvm.mul %[[VAL_7]], %[[VAL_6]] : i32 |
| 967 |
// CHECK: %[[VAL_9:.*]] = llvm.add %[[VAL_3]], %[[VAL_8]] : i32 |
| 968 |
// CHECK: "llvm.intr.memcpy"(%[[VAL_2]], %[[VAL_0]], %[[VAL_9]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> () |
| 969 |
// CHECK: llvm.call @some_assumed_rank_func(%[[VAL_2]]) : (!llvm.ptr) -> () |
| 970 |
|
| 971 |
// ----- |
| 972 |
|
| 973 |
// Test `fir.box_rank` conversion. |
| 974 |
|
| 975 |
func.func @extract_rank(%arg0: !fir.box<!fir.array<*:f64>>) -> i32 { |
| 976 |
%0 = fir.box_rank %arg0 : (!fir.box<!fir.array<*:f64>>) -> i32 |
| 977 |
return %0 : i32 |
| 978 |
} |
| 979 |
|
| 980 |
// CHECK-LABEL: llvm.func @extract_rank( |
| 981 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i32 |
| 982 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 983 |
// CHECK: %[[RAW_RANK:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> i8 |
| 984 |
// CHECK: %[[RANK:.*]] = llvm.sext %[[RAW_RANK]] : i8 to i32 |
| 985 |
// CHECK: llvm.return %[[RANK]] : i32 |
| 986 |
|
| 987 |
func.func @extract_rank2(%arg0: !fir.ref<!fir.box<!fir.array<*:f64>>>) -> i32 { |
| 988 |
%0 = fir.box_rank %arg0 : (!fir.ref<!fir.box<!fir.array<*:f64>>>) -> i32 |
| 989 |
return %0 : i32 |
| 990 |
} |
| 991 |
|
| 992 |
// CHECK-LABEL: llvm.func @extract_rank2( |
| 993 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i32 |
| 994 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 995 |
// CHECK: %[[RAW_RANK:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> i8 |
| 996 |
// CHECK: %[[RANK:.*]] = llvm.sext %[[RAW_RANK]] : i8 to i32 |
| 997 |
// CHECK: llvm.return %[[RANK]] : i32 |
| 998 |
|
| 999 |
// ----- |
| 1000 |
|
| 1001 |
// Test `fir.box_addr` conversion. |
| 1002 |
|
| 1003 |
func.func @extract_addr(%arg0: !fir.box<!fir.array<*:f64>>) -> !fir.ref<f64> { |
| 1004 |
%0 = fir.box_addr %arg0 : (!fir.box<!fir.array<*:f64>>) -> !fir.ref<f64> |
| 1005 |
return %0 : !fir.ref<f64> |
| 1006 |
} |
| 1007 |
|
| 1008 |
// CHECK-LABEL: llvm.func @extract_addr( |
| 1009 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> !llvm.ptr |
| 1010 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1011 |
// CHECK: %[[ADDR:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> !llvm.ptr |
| 1012 |
// CHECK: llvm.return %[[ADDR]] : !llvm.ptr |
| 1013 |
|
| 1014 |
// ----- |
| 1015 |
|
| 1016 |
// Test `fir.box_dims` conversion. |
| 1017 |
|
| 1018 |
func.func @extract_dims(%arg0: !fir.box<!fir.array<*:f64>>) -> index { |
| 1019 |
%c1 = arith.constant 0 : i32 |
| 1020 |
%cast = fir.convert %arg0 : (!fir.box<!fir.array<*:f64>>) -> !fir.box<!fir.array<?xf64>> |
| 1021 |
%0:3 = fir.box_dims %cast, %c1 : (!fir.box<!fir.array<?xf64>>, i32) -> (index, index, index) |
| 1022 |
return %0 : index |
| 1023 |
} |
| 1024 |
|
| 1025 |
// CHECK-LABEL: llvm.func @extract_dims( |
| 1026 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i64 |
| 1027 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1028 |
// CHECK: %[[GEP0:.*]] = llvm.getelementptr %[[ARG0]][0, 7, %[[C0]], 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1029 |
// CHECK: %[[LOAD0:.*]] = llvm.load %[[GEP0]] : !llvm.ptr -> i64 |
| 1030 |
// CHECK: %[[GEP1:.*]] = llvm.getelementptr %[[ARG0]][0, 7, %[[C0]], 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1031 |
// CHECK: %[[LOAD1:.*]] = llvm.load %[[GEP1]] : !llvm.ptr -> i64 |
| 1032 |
// CHECK: %[[GEP2:.*]] = llvm.getelementptr %[[ARG0]][0, 7, %[[C0]], 2] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1033 |
// CHECK: %[[LOAD2:.*]] = llvm.load %[[GEP2]] : !llvm.ptr -> i64 |
| 1034 |
// CHECK: llvm.return %[[LOAD0]] : i64 |
| 1035 |
|
| 1036 |
// ----- |
| 1037 |
|
| 1038 |
// Test `fir.box_elesize` conversion. |
| 1039 |
|
| 1040 |
func.func @extract_elesize(%arg0: !fir.box<f32>) -> i32 { |
| 1041 |
%0 = fir.box_elesize %arg0 : (!fir.box<f32>) -> i32 |
| 1042 |
return %0 : i32 |
| 1043 |
} |
| 1044 |
|
| 1045 |
// CHECK-LABEL: llvm.func @extract_elesize( |
| 1046 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i32 |
| 1047 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1048 |
// CHECK: %[[ELE_SIZE:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> i64 |
| 1049 |
// CHECK: %[[ELE_SIZE_CONV:.*]] = llvm.trunc %[[ELE_SIZE]] : i64 to i32 |
| 1050 |
// CHECK: llvm.return %[[ELE_SIZE_CONV]] : i32 |
| 1051 |
|
| 1052 |
// ----- |
| 1053 |
|
| 1054 |
// Test `fir.box_isarray` conversion. |
| 1055 |
// `rank` is extracted from `fir.box` and compare to 0. |
| 1056 |
|
| 1057 |
func.func @box_isarray(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 { |
| 1058 |
%0 = fir.box_isarray %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1 |
| 1059 |
return %0 : i1 |
| 1060 |
} |
| 1061 |
|
| 1062 |
// CHECK-LABEL: llvm.func @box_isarray( |
| 1063 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i1 |
| 1064 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1065 |
// CHECK: %[[RANK:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> i8 |
| 1066 |
// CHECK: %[[C0_ISARRAY:.*]] = llvm.mlir.constant(0 : i64) : i8 |
| 1067 |
// CHECK: %[[IS_ARRAY:.*]] = llvm.icmp "ne" %[[RANK]], %[[C0_ISARRAY]] : i8 |
| 1068 |
// CHECK: llvm.return %[[IS_ARRAY]] : i1 |
| 1069 |
|
| 1070 |
// ----- |
| 1071 |
|
| 1072 |
// Test `fir.box_isalloc` conversion. |
| 1073 |
// `attribute` is extracted from `fir.box` and checked against a mask equal to |
| 1074 |
// the value of `CFI_attribute_allocatable`. |
| 1075 |
|
| 1076 |
func.func @box_isalloc(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 { |
| 1077 |
%0 = fir.box_isalloc %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1 |
| 1078 |
return %0 : i1 |
| 1079 |
} |
| 1080 |
|
| 1081 |
// CHECK-LABEL: llvm.func @box_isalloc( |
| 1082 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i1 |
| 1083 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1084 |
// CHECK: %[[ATTR:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> i8 |
| 1085 |
// CHECK: %[[ATTR_CONV:.*]] = llvm.sext %[[ATTR]] : i8 to i32 |
| 1086 |
// CHECK: %[[ATTR_ISALLOC:.*]] = llvm.mlir.constant(2 : i32) : i32 |
| 1087 |
// CHECK: %[[AND:.*]] = llvm.and %[[ATTR_CONV]], %[[ATTR_ISALLOC]] : i32 |
| 1088 |
// CHECK: %[[CMP_C0:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1089 |
// CHECK: %[[IS_ALLOC:.*]] = llvm.icmp "ne" %[[AND]], %[[CMP_C0]] : i32 |
| 1090 |
// CHECK: llvm.return %[[IS_ALLOC]] : i1 |
| 1091 |
|
| 1092 |
// ----- |
| 1093 |
|
| 1094 |
// Test `fir.box_isptr` conversion. |
| 1095 |
// `attribute` is extracted from `fir.box` and checked against a mask equal to |
| 1096 |
// the value of `CFI_attribute_pointer`. |
| 1097 |
|
| 1098 |
func.func @box_isptr(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 { |
| 1099 |
%0 = fir.box_isptr %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1 |
| 1100 |
return %0 : i1 |
| 1101 |
} |
| 1102 |
|
| 1103 |
// CHECK-LABEL: llvm.func @box_isptr( |
| 1104 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i1 |
| 1105 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1106 |
// CHECK: %[[ATTR:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> i8 |
| 1107 |
// CHECK: %[[ATTR_CONV:.*]] = llvm.sext %[[ATTR]] : i8 to i32 |
| 1108 |
// CHECK: %[[ATTR_ISALLOC:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1109 |
// CHECK: %[[AND:.*]] = llvm.and %[[ATTR_CONV]], %[[ATTR_ISALLOC]] : i32 |
| 1110 |
// CHECK: %[[CMP_C0:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1111 |
// CHECK: %[[IS_ALLOC:.*]] = llvm.icmp "ne" %[[AND]], %[[CMP_C0]] : i32 |
| 1112 |
// CHECK: llvm.return %[[IS_ALLOC]] : i1 |
| 1113 |
|
| 1114 |
// ----- |
| 1115 |
|
| 1116 |
// Test fir.alloca of one element |
| 1117 |
|
| 1118 |
func.func @alloca_one() -> !fir.ref<i32> { |
| 1119 |
%1 = fir.alloca i32 |
| 1120 |
return %1 : !fir.ref<i32> |
| 1121 |
} |
| 1122 |
|
| 1123 |
// CHECK-LABEL: llvm.func @alloca_one() -> !llvm.ptr |
| 1124 |
// CHECK: [[N:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1125 |
// GENERIC: [[A:%.*]] = llvm.alloca [[N]] x i32 |
| 1126 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[N]] x i32 : (i64) -> !llvm.ptr<5> |
| 1127 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1128 |
// CHECK: llvm.return [[A]] : !llvm.ptr |
| 1129 |
|
| 1130 |
|
| 1131 |
// ----- |
| 1132 |
|
| 1133 |
// Test fir.alloca of several elements |
| 1134 |
|
| 1135 |
func.func @alloca_several() -> !fir.ref<i32> { |
| 1136 |
%0 = arith.constant 100 : index |
| 1137 |
%1 = fir.alloca i32, %0 |
| 1138 |
return %1 : !fir.ref<i32> |
| 1139 |
} |
| 1140 |
|
| 1141 |
// CHECK-LABEL: llvm.func @alloca_several() -> !llvm.ptr |
| 1142 |
// CHECK: [[N:%.*]] = llvm.mlir.constant(100 : index) : i64 |
| 1143 |
// CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1144 |
// CHECK: [[TOTAL:%.*]] = llvm.mul [[ONE]], [[N]] : i64 |
| 1145 |
// GENERIC: [[A:%.*]] = llvm.alloca [[TOTAL]] x i32 |
| 1146 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[TOTAL]] x i32 : (i64) -> !llvm.ptr<5> |
| 1147 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1148 |
// CHECK: llvm.return [[A]] : !llvm.ptr |
| 1149 |
|
| 1150 |
// ----- |
| 1151 |
|
| 1152 |
// Test fir.alloca of pointer to array |
| 1153 |
|
| 1154 |
func.func @alloca_ptr_to_array() -> !fir.ref<!fir.ptr<!fir.array<?xi32>>> { |
| 1155 |
%1 = fir.alloca !fir.ptr<!fir.array<?xi32>> |
| 1156 |
return %1 : !fir.ref<!fir.ptr<!fir.array<?xi32>>> |
| 1157 |
} |
| 1158 |
|
| 1159 |
// CHECK-LABEL: llvm.func @alloca_ptr_to_array() -> !llvm.ptr |
| 1160 |
// CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1161 |
// GENERIC: [[A:%.*]] = llvm.alloca [[ONE]] x !llvm.ptr |
| 1162 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[ONE]] x !llvm.ptr : (i64) -> !llvm.ptr<5> |
| 1163 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1164 |
// CHECK: llvm.return [[A]] : !llvm.ptr |
| 1165 |
|
| 1166 |
// ----- |
| 1167 |
|
| 1168 |
// Test fir.alloca of array of unknown-length chars |
| 1169 |
|
| 1170 |
func.func @alloca_char_array(%l: i32, %e : index) -> !fir.ref<!fir.array<?x?x!fir.char<1,?>>> { |
| 1171 |
%a = fir.alloca !fir.array<?x?x!fir.char<1,?>>(%l : i32), %e, %e |
| 1172 |
return %a : !fir.ref<!fir.array<?x?x!fir.char<1,?>>> |
| 1173 |
} |
| 1174 |
|
| 1175 |
// CHECK-LABEL: llvm.func @alloca_char_array |
| 1176 |
// CHECK-SAME: ([[L:%.*]]: i32, [[E:%.*]]: i64) -> !llvm.ptr |
| 1177 |
// CHECK-DAG: [[UNUSEDONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1178 |
// CHECK-DAG: [[LCAST:%.*]] = llvm.sext [[L]] : i32 to i64 |
| 1179 |
// CHECK: [[PROD1:%.*]] = llvm.mul [[LCAST]], [[E]] : i64 |
| 1180 |
// CHECK: [[PROD2:%.*]] = llvm.mul [[PROD1]], [[E]] : i64 |
| 1181 |
// GENERIC: [[A:%.*]] = llvm.alloca [[PROD2]] x i8 |
| 1182 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[PROD2]] x i8 : (i64) -> !llvm.ptr<5> |
| 1183 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1184 |
// CHECK: return [[A]] : !llvm.ptr |
| 1185 |
|
| 1186 |
// ----- |
| 1187 |
|
| 1188 |
// Test fir.alloca of array of known-length chars |
| 1189 |
|
| 1190 |
func.func @alloca_fixed_char_array(%e : index) -> !fir.ref<!fir.array<?x?x!fir.char<1,8>>> { |
| 1191 |
%a = fir.alloca !fir.array<?x?x!fir.char<1,8>>, %e, %e |
| 1192 |
return %a : !fir.ref<!fir.array<?x?x!fir.char<1,8>>> |
| 1193 |
} |
| 1194 |
|
| 1195 |
// CHECK-LABEL: llvm.func @alloca_fixed_char_array |
| 1196 |
// CHECK-SAME: ([[E:%.*]]: i64) -> !llvm.ptr |
| 1197 |
// CHECK-DAG: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1198 |
// CHECK: [[PROD1:%.*]] = llvm.mul [[E]], [[ONE]] : i64 |
| 1199 |
// CHECK: [[PROD2:%.*]] = llvm.mul [[PROD1]], [[E]] : i64 |
| 1200 |
// GENERIC: [[A:%.*]] = llvm.alloca [[PROD2]] x !llvm.array<8 x i8> |
| 1201 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[PROD2]] x !llvm.array<8 x i8> : (i64) -> !llvm.ptr<5> |
| 1202 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1203 |
// CHECK: return [[A]] : !llvm.ptr |
| 1204 |
|
| 1205 |
// ----- |
| 1206 |
|
| 1207 |
// Test fir.alloca of record type with LEN parameters |
| 1208 |
// type t(p1,p2) |
| 1209 |
// integer, len :: p1 |
| 1210 |
// integer(kind=2), len :: p2 |
| 1211 |
// integer f1 |
| 1212 |
// real f2 |
| 1213 |
// end type t |
| 1214 |
|
| 1215 |
func.func private @_QTtP.mem.size(%0 : i32, %1 : i16) -> index |
| 1216 |
|
| 1217 |
func.func @alloca_record(%arg0 : i32, %arg1 : i16) -> !fir.ref<!fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>> { |
| 1218 |
%0 = fir.alloca !fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>(%arg0, %arg1 : i32, i16) {name = "_QEvar"} |
| 1219 |
return %0 : !fir.ref<!fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>> |
| 1220 |
} |
| 1221 |
|
| 1222 |
// CHECK-LABEL: llvm.func @alloca_record |
| 1223 |
// CHECK-SAME: ([[ARG0:%.*]]: i32, [[ARG1:%.*]]: i16) |
| 1224 |
// CHECK-SAME: -> !llvm.ptr |
| 1225 |
// CHECK: [[SIZE:%.*]] = llvm.call @_QTtP.mem.size([[ARG0]], [[ARG1]]) : (i32, i16) -> i64 |
| 1226 |
// GENERIC: [[ALLOC:%.*]] = llvm.alloca [[SIZE]] x i8 |
| 1227 |
// AMDGPU: [[A:%.*]] = llvm.alloca [[SIZE]] x i8 : (i64) -> !llvm.ptr<5> |
| 1228 |
// AMDGPU: [[ALLOC:%.*]] = llvm.addrspacecast [[A]] : !llvm.ptr<5> to !llvm.ptr |
| 1229 |
// CHECK: llvm.return [[ALLOC]] : !llvm.ptr |
| 1230 |
|
| 1231 |
// ----- |
| 1232 |
|
| 1233 |
// Test fir.alloca of a multidimensional array, with operands |
| 1234 |
|
| 1235 |
func.func @alloca_multidim_array(%0 : index) -> !fir.ref<!fir.array<8x16x32xf32>> { |
| 1236 |
%1 = arith.constant 24 : index |
| 1237 |
%2 = fir.alloca !fir.array<8x16x32xf32>, %0, %1 |
| 1238 |
return %2 : !fir.ref<!fir.array<8x16x32xf32>> |
| 1239 |
} |
| 1240 |
|
| 1241 |
// CHECK-LABEL: llvm.func @alloca_multidim_array |
| 1242 |
// CHECK-SAME: ([[OP1:%.*]]: i64) -> !llvm.ptr |
| 1243 |
// CHECK: [[OP2:%.*]] = llvm.mlir.constant(24 : index) : i64 |
| 1244 |
// CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1245 |
// CHECK: [[MUL1:%.*]] = llvm.mul [[OP1]], [[ONE]] : i64 |
| 1246 |
// CHECK: [[TOTAL:%.*]] = llvm.mul [[MUL1]], [[OP2]] : i64 |
| 1247 |
// GENERIC: [[A:%.*]] = llvm.alloca [[TOTAL]] x !llvm.array<32 x array<16 x array<8 x f32>>> |
| 1248 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[TOTAL]] x !llvm.array<32 x array<16 x array<8 x f32>>> : (i64) -> !llvm.ptr<5> |
| 1249 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1250 |
// CHECK: llvm.return [[A]] : !llvm.ptr |
| 1251 |
|
| 1252 |
// ----- |
| 1253 |
|
| 1254 |
// Test fir.alloca of a multidimensional array with constant interior |
| 1255 |
|
| 1256 |
func.func @alloca_const_interior_array(%0 : index) -> !fir.ref<!fir.array<8x9x?x?xf32>> { |
| 1257 |
%1 = arith.constant 64 : index |
| 1258 |
%2 = fir.alloca !fir.array<8x9x?x?xf32>, %0, %1 |
| 1259 |
return %2 : !fir.ref<!fir.array<8x9x?x?xf32>> |
| 1260 |
} |
| 1261 |
|
| 1262 |
// CHECK-LABEL: llvm.func @alloca_const_interior_array |
| 1263 |
// CHECK-SAME: ([[OP1:%.*]]: i64) -> !llvm.ptr |
| 1264 |
// CHECK: [[OP2:%.*]] = llvm.mlir.constant(64 : index) : i64 |
| 1265 |
// CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1266 |
// CHECK: [[MUL1:%.*]] = llvm.mul [[OP1]], [[ONE]] : i64 |
| 1267 |
// CHECK: [[TOTAL:%.*]] = llvm.mul [[MUL1]], [[OP2]] : i64 |
| 1268 |
// GENERIC: [[A:%.*]] = llvm.alloca [[TOTAL]] x !llvm.array<9 x array<8 x f32>> |
| 1269 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[TOTAL]] x !llvm.array<9 x array<8 x f32>> : (i64) -> !llvm.ptr<5> |
| 1270 |
// AMDGPU: [[A:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1271 |
// CHECK: llvm.return [[A]] : !llvm.ptr |
| 1272 |
|
| 1273 |
// ----- |
| 1274 |
|
| 1275 |
// Test alloca with an array with holes. |
| 1276 |
// Constant factor of 60 (4*3*5) must be included. |
| 1277 |
|
| 1278 |
func.func @alloca_array_with_holes(%0 : index, %1 : index) -> !fir.ref<!fir.array<4x?x3x?x5xi32>> { |
| 1279 |
%a = fir.alloca !fir.array<4x?x3x?x5xi32>, %0, %1 |
| 1280 |
return %a : !fir.ref<!fir.array<4x?x3x?x5xi32>> |
| 1281 |
} |
| 1282 |
|
| 1283 |
// CHECK-LABEL: llvm.func @alloca_array_with_holes |
| 1284 |
// CHECK-SAME: ([[A:%.*]]: i64, [[B:%.*]]: i64) -> !llvm.ptr |
| 1285 |
// CHECK-DAG: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1286 |
// CHECK-DAG: [[FIXED:%.*]] = llvm.mlir.constant(15 : i64) : i64 |
| 1287 |
// CHECK: [[PROD1:%.*]] = llvm.mul [[ONE]], [[FIXED]] : i64 |
| 1288 |
// CHECK: [[PROD2:%.*]] = llvm.mul [[PROD1]], [[A]] : i64 |
| 1289 |
// CHECK: [[PROD3:%.*]] = llvm.mul [[PROD2]], [[B]] : i64 |
| 1290 |
// GENERIC: [[RES:%.*]] = llvm.alloca [[PROD3]] x !llvm.array<4 x i32> |
| 1291 |
// AMDGPU: [[AA:%.*]] = llvm.alloca [[PROD3]] x !llvm.array<4 x i32> : (i64) -> !llvm.ptr<5> |
| 1292 |
// AMDGPU: [[RES:%.*]] = llvm.addrspacecast [[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1293 |
// CHECK: llvm.return [[RES]] : !llvm.ptr |
| 1294 |
|
| 1295 |
// ----- |
| 1296 |
|
| 1297 |
// Test alloca of assumed-rank box |
| 1298 |
|
| 1299 |
func.func @alloca_assumed_rank_box() -> !fir.ref<!fir.box<!fir.array<*:f32>>> { |
| 1300 |
%a = fir.alloca !fir.box<!fir.array<*:f32>> |
| 1301 |
return %a : !fir.ref<!fir.box<!fir.array<*:f32>>> |
| 1302 |
} |
| 1303 |
// CHECK-LABEL: llvm.func @alloca_assumed_rank_box |
| 1304 |
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1305 |
// GENERIC: llvm.alloca %[[ONE]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> : (i64) -> !llvm.ptr |
| 1306 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[ONE]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> : (i64) -> !llvm.ptr<5> |
| 1307 |
// AMDGPU: llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1308 |
|
| 1309 |
// ----- |
| 1310 |
|
| 1311 |
// Test `fir.select_case` operation conversion with INTEGER. |
| 1312 |
|
| 1313 |
func.func @select_case_integer(%arg0: !fir.ref<i32>) -> i32 { |
| 1314 |
%2 = fir.load %arg0 : !fir.ref<i32> |
| 1315 |
%c1_i32 = arith.constant 1 : i32 |
| 1316 |
%c2_i32 = arith.constant 2 : i32 |
| 1317 |
%c4_i32 = arith.constant 4 : i32 |
| 1318 |
%c5_i32 = arith.constant 5 : i32 |
| 1319 |
%c7_i32 = arith.constant 7 : i32 |
| 1320 |
%c8_i32 = arith.constant 8 : i32 |
| 1321 |
%c15_i32 = arith.constant 15 : i32 |
| 1322 |
%c21_i32 = arith.constant 21 : i32 |
| 1323 |
fir.select_case %2 : i32 [#fir.upper, %c1_i32, ^bb1, |
| 1324 |
#fir.point, %c2_i32, ^bb2, |
| 1325 |
#fir.interval, %c4_i32, %c5_i32, ^bb4, |
| 1326 |
#fir.point, %c7_i32, ^bb5, |
| 1327 |
#fir.interval, %c8_i32, %c15_i32, ^bb5, |
| 1328 |
#fir.lower, %c21_i32, ^bb5, |
| 1329 |
unit, ^bb3] |
| 1330 |
^bb1: // pred: ^bb0 |
| 1331 |
%c1_i32_0 = arith.constant 1 : i32 |
| 1332 |
fir.store %c1_i32_0 to %arg0 : !fir.ref<i32> |
| 1333 |
cf.br ^bb6 |
| 1334 |
^bb2: // pred: ^bb0 |
| 1335 |
%c2_i32_1 = arith.constant 2 : i32 |
| 1336 |
fir.store %c2_i32_1 to %arg0 : !fir.ref<i32> |
| 1337 |
cf.br ^bb6 |
| 1338 |
^bb3: // pred: ^bb0 |
| 1339 |
%c0_i32 = arith.constant 0 : i32 |
| 1340 |
fir.store %c0_i32 to %arg0 : !fir.ref<i32> |
| 1341 |
cf.br ^bb6 |
| 1342 |
^bb4: // pred: ^bb0 |
| 1343 |
%c4_i32_2 = arith.constant 4 : i32 |
| 1344 |
fir.store %c4_i32_2 to %arg0 : !fir.ref<i32> |
| 1345 |
cf.br ^bb6 |
| 1346 |
^bb5: // 3 preds: ^bb0, ^bb0, ^bb0 |
| 1347 |
%c7_i32_3 = arith.constant 7 : i32 |
| 1348 |
fir.store %c7_i32_3 to %arg0 : !fir.ref<i32> |
| 1349 |
cf.br ^bb6 |
| 1350 |
^bb6: // 5 preds: ^bb1, ^bb2, ^bb3, ^bb4, ^bb5 |
| 1351 |
%3 = fir.load %arg0 : !fir.ref<i32> |
| 1352 |
return %3 : i32 |
| 1353 |
} |
| 1354 |
|
| 1355 |
// CHECK-LABEL: llvm.func @select_case_integer( |
| 1356 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) -> i32 { |
| 1357 |
// CHECK: %[[SELECT_VALUE:.*]] = llvm.load %[[ARG0]] : !llvm.ptr -> i32 |
| 1358 |
// CHECK: %[[CST1:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1359 |
// CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i32) : i32 |
| 1360 |
// CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i32) : i32 |
| 1361 |
// CHECK: %[[CST5:.*]] = llvm.mlir.constant(5 : i32) : i32 |
| 1362 |
// CHECK: %[[CST7:.*]] = llvm.mlir.constant(7 : i32) : i32 |
| 1363 |
// CHECK: %[[CST8:.*]] = llvm.mlir.constant(8 : i32) : i32 |
| 1364 |
// CHECK: %[[CST15:.*]] = llvm.mlir.constant(15 : i32) : i32 |
| 1365 |
// CHECK: %[[CST21:.*]] = llvm.mlir.constant(21 : i32) : i32 |
| 1366 |
// Check for upper bound `case (:1)` |
| 1367 |
// CHECK: %[[CMP_SLE:.*]] = llvm.icmp "sle" %[[SELECT_VALUE]], %[[CST1]] : i32 |
| 1368 |
// CHECK: llvm.cond_br %[[CMP_SLE]], ^bb2, ^bb1 |
| 1369 |
// CHECK-LABEL: ^bb1: |
| 1370 |
// Check for point value `case (2)` |
| 1371 |
// CHECK: %[[CMP_EQ:.*]] = llvm.icmp "eq" %[[SELECT_VALUE]], %[[CST2]] : i32 |
| 1372 |
// CHECK: llvm.cond_br %[[CMP_EQ]], ^bb4, ^bb3 |
| 1373 |
// Block ^bb1 in original FIR code. |
| 1374 |
// CHECK-LABEL: ^bb2: |
| 1375 |
// CHECK: llvm.br ^bb{{.*}} |
| 1376 |
// CHECK-LABEL: ^bb3: |
| 1377 |
// Check for the lower bound for the interval `case (4:5)` |
| 1378 |
// CHECK: %[[CMP_SLE:.*]] = llvm.icmp "sle" %[[CST4]], %[[SELECT_VALUE]] : i32 |
| 1379 |
// CHECK: llvm.cond_br %[[CMP_SLE]], ^bb[[UPPERBOUND5:.*]], ^bb7 |
| 1380 |
// Block ^bb2 in original FIR code. |
| 1381 |
// CHECK-LABEL: ^bb4: |
| 1382 |
// CHECK: llvm.br ^bb{{.*}} |
| 1383 |
// Block ^bb3 in original FIR code. |
| 1384 |
// CHECK-LABEL: ^bb5: |
| 1385 |
// CHECK: llvm.br ^bb{{.*}} |
| 1386 |
// CHECK: ^bb[[UPPERBOUND5]]: |
| 1387 |
// Check for the upper bound for the interval `case (4:5)` |
| 1388 |
// CHECK: %[[CMP_SLE:.*]] = llvm.icmp "sle" %[[SELECT_VALUE]], %[[CST5]] : i32 |
| 1389 |
// CHECK: llvm.cond_br %[[CMP_SLE]], ^bb8, ^bb7 |
| 1390 |
// CHECK-LABEL: ^bb7: |
| 1391 |
// Check for the point value 7 in `case (7,8:15,21:)` |
| 1392 |
// CHECK: %[[CMP_EQ:.*]] = llvm.icmp "eq" %[[SELECT_VALUE]], %[[CST7]] : i32 |
| 1393 |
// CHECK: llvm.cond_br %[[CMP_EQ]], ^bb13, ^bb9 |
| 1394 |
// Block ^bb4 in original FIR code. |
| 1395 |
// CHECK-LABEL: ^bb8: |
| 1396 |
// CHECK: llvm.br ^bb{{.*}} |
| 1397 |
// CHECK-LABEL: ^bb9: |
| 1398 |
// Check for lower bound 8 in `case (7,8:15,21:)` |
| 1399 |
// CHECK: %[[CMP_SLE:.*]] = llvm.icmp "sle" %[[CST8]], %[[SELECT_VALUE]] : i32 |
| 1400 |
// CHECK: llvm.cond_br %[[CMP_SLE]], ^bb[[INTERVAL8_15:.*]], ^bb11 |
| 1401 |
// CHECK: ^bb[[INTERVAL8_15]]: |
| 1402 |
// Check for upper bound 15 in `case (7,8:15,21:)` |
| 1403 |
// CHECK: %[[CMP_SLE:.*]] = llvm.icmp "sle" %[[SELECT_VALUE]], %[[CST15]] : i32 |
| 1404 |
// CHECK: llvm.cond_br %[[CMP_SLE]], ^bb13, ^bb11 |
| 1405 |
// CHECK-LABEL: ^bb11: |
| 1406 |
// Check for lower bound 21 in `case (7,8:15,21:)` |
| 1407 |
// CHECK: %[[CMP_SLE:.*]] = llvm.icmp "sle" %[[CST21]], %[[SELECT_VALUE]] : i32 |
| 1408 |
// CHECK: llvm.cond_br %[[CMP_SLE]], ^bb13, ^bb12 |
| 1409 |
// CHECK-LABEL: ^bb12: |
| 1410 |
// CHECK: llvm.br ^bb5 |
| 1411 |
// Block ^bb5 in original FIR code. |
| 1412 |
// CHECK-LABEL: ^bb13: |
| 1413 |
// CHECK: llvm.br ^bb14 |
| 1414 |
// Block ^bb6 in original FIR code. |
| 1415 |
// CHECK-LABEL: ^bb14: |
| 1416 |
// CHECK: %[[RET:.*]] = llvm.load %[[ARG0:.*]] : !llvm.ptr -> i32 |
| 1417 |
// CHECK: llvm.return %[[RET]] : i32 |
| 1418 |
|
| 1419 |
// ----- |
| 1420 |
|
| 1421 |
// Test `fir.select_case` operation conversion with LOGICAL. |
| 1422 |
|
| 1423 |
func.func @select_case_logical(%arg0: !fir.ref<!fir.logical<4>>) { |
| 1424 |
%1 = fir.load %arg0 : !fir.ref<!fir.logical<4>> |
| 1425 |
%2 = fir.convert %1 : (!fir.logical<4>) -> i1 |
| 1426 |
%false = arith.constant false |
| 1427 |
%true = arith.constant true |
| 1428 |
fir.select_case %2 : i1 [#fir.point, %false, ^bb1, |
| 1429 |
#fir.point, %true, ^bb2, |
| 1430 |
unit, ^bb3] |
| 1431 |
^bb1: |
| 1432 |
%c1_i32 = arith.constant 1 : i32 |
| 1433 |
cf.br ^bb3 |
| 1434 |
^bb2: |
| 1435 |
%c2_i32 = arith.constant 2 : i32 |
| 1436 |
cf.br ^bb3 |
| 1437 |
^bb3: |
| 1438 |
return |
| 1439 |
} |
| 1440 |
|
| 1441 |
// CHECK-LABEL: llvm.func @select_case_logical( |
| 1442 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 1443 |
// CHECK: %[[LOAD_ARG0:.*]] = llvm.load %[[ARG0]] : !llvm.ptr -> i32 |
| 1444 |
// CHECK: %[[CST_ZERO:.*]] = llvm.mlir.constant(0 : i64) : i32 |
| 1445 |
// CHECK: %[[SELECT_VALUE:.*]] = llvm.icmp "ne" %[[LOAD_ARG0]], %[[CST_ZERO]] : i32 |
| 1446 |
// CHECK: %[[CST_FALSE:.*]] = llvm.mlir.constant(false) : i1 |
| 1447 |
// CHECK: %[[CST_TRUE:.*]] = llvm.mlir.constant(true) : i1 |
| 1448 |
// CHECK: %[[CMPEQ:.*]] = llvm.icmp "eq" %[[SELECT_VALUE]], %[[CST_FALSE]] : i1 |
| 1449 |
// CHECK: llvm.cond_br %[[CMPEQ]], ^bb2, ^bb1 |
| 1450 |
// CHECK-LABEL: ^bb1: |
| 1451 |
// CHECK: %[[CMPEQ:.*]] = llvm.icmp "eq" %[[SELECT_VALUE]], %[[CST_TRUE]] : i1 |
| 1452 |
// CHECK: llvm.cond_br %[[CMPEQ]], ^bb4, ^bb3 |
| 1453 |
// CHECK-LABEL: ^bb2: |
| 1454 |
// CHECK: llvm.br ^bb5 |
| 1455 |
// CHECK-LABEL: ^bb3: |
| 1456 |
// CHECK: llvm.br ^bb5 |
| 1457 |
// CHECK-LABEL: ^bb4: |
| 1458 |
// CHECK: llvm.br ^bb5 |
| 1459 |
// CHECK-LABEL: ^bb5: |
| 1460 |
// CHECK: llvm.return |
| 1461 |
|
| 1462 |
// ----- |
| 1463 |
|
| 1464 |
// Test `fir.is_present` |
| 1465 |
|
| 1466 |
func.func @test_is_present_i64(%arg0: !fir.ref<i64>) -> () { |
| 1467 |
%0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1 |
| 1468 |
return |
| 1469 |
} |
| 1470 |
|
| 1471 |
// CHECK-LABEL: @test_is_present_i64 |
| 1472 |
// CHECK-SAME: (%[[arg:.*]]: !llvm.ptr) |
| 1473 |
// CHECK-NEXT: %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1474 |
// CHECK-NEXT: %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr to i64 |
| 1475 |
// CHECK-NEXT: %{{.*}} = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64 |
| 1476 |
// CHECK-NEXT: llvm.return |
| 1477 |
// CHECK-NEXT: } |
| 1478 |
|
| 1479 |
func.func @test_is_present_box(%arg0: !fir.box<!fir.ref<i64>>) -> () { |
| 1480 |
%0 = fir.is_present %arg0 : (!fir.box<!fir.ref<i64>>) -> i1 |
| 1481 |
return |
| 1482 |
} |
| 1483 |
|
| 1484 |
// CHECK-LABEL: @test_is_present_box |
| 1485 |
// CHECK-SAME: (%[[arg:.*]]: !llvm.ptr) |
| 1486 |
// CHECK-NEXT: %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1487 |
// CHECK-NEXT: %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr to i64 |
| 1488 |
// CHECK-NEXT: %{{.*}} = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64 |
| 1489 |
// CHECK-NEXT: llvm.return |
| 1490 |
// CHECK-NEXT: } |
| 1491 |
|
| 1492 |
|
| 1493 |
// ----- |
| 1494 |
|
| 1495 |
// Test `fir.absent` |
| 1496 |
|
| 1497 |
func.func @test_absent_i64() -> () { |
| 1498 |
%0 = fir.absent !fir.ref<i64> |
| 1499 |
return |
| 1500 |
} |
| 1501 |
|
| 1502 |
// CHECK-LABEL: @test_absent_i64 |
| 1503 |
// CHECK-NEXT: %{{.*}} = llvm.mlir.zero : !llvm.ptr |
| 1504 |
// CHECK-NEXT: llvm.return |
| 1505 |
// CHECK-NEXT: } |
| 1506 |
|
| 1507 |
func.func @test_absent_box() -> () { |
| 1508 |
%0 = fir.absent !fir.box<!fir.array<?xf32>> |
| 1509 |
return |
| 1510 |
} |
| 1511 |
// CHECK-LABEL: @test_absent_box |
| 1512 |
// CHECK-NEXT: %{{.*}} = llvm.mlir.zero : !llvm.ptr |
| 1513 |
// CHECK-NEXT: llvm.return |
| 1514 |
// CHECK-NEXT: } |
| 1515 |
|
| 1516 |
// ----- |
| 1517 |
|
| 1518 |
// This is a bit more comprehensive test for `fir.is_present` and `fir.absent` |
| 1519 |
// when used together |
| 1520 |
|
| 1521 |
func.func @is_present(%arg0: !fir.ref<i64>) -> i1 { |
| 1522 |
%0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1 |
| 1523 |
return %0 : i1 |
| 1524 |
} |
| 1525 |
|
| 1526 |
// CHECK-LABEL: @is_present |
| 1527 |
// CHECK-SAME: (%[[arg:.*]]: !llvm.ptr) -> i1 |
| 1528 |
// CHECK-NEXT: %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1529 |
// CHECK-NEXT: %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr to i64 |
| 1530 |
// CHECK-NEXT: %[[ret_val:.*]] = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64 |
| 1531 |
// CHECK-NEXT: llvm.return %[[ret_val]] : i1 |
| 1532 |
// CHECK-NEXT: } |
| 1533 |
|
| 1534 |
func.func @absent() -> i1 { |
| 1535 |
%0 = fir.absent !fir.ref<i64> |
| 1536 |
%1 = fir.call @is_present(%0) : (!fir.ref<i64>) -> i1 |
| 1537 |
return %1 : i1 |
| 1538 |
} |
| 1539 |
|
| 1540 |
// CHECK-LABEL: @absent |
| 1541 |
// CHECK-SAME: () -> i1 |
| 1542 |
// CHECK-NEXT: %[[ptr:.*]] = llvm.mlir.zero : !llvm.ptr |
| 1543 |
// CHECK-NEXT: %[[ret_val:.*]] = llvm.call @is_present(%[[ptr]]) : (!llvm.ptr) -> i1 |
| 1544 |
// CHECK-NEXT: llvm.return %[[ret_val]] : i1 |
| 1545 |
|
| 1546 |
// ----- |
| 1547 |
|
| 1548 |
// Test `fir.string_lit` conversion. |
| 1549 |
|
| 1550 |
func.func @string_lit0() { |
| 1551 |
%1 = fir.string_lit "Hello, World!"(13) : !fir.char<1> |
| 1552 |
return |
| 1553 |
} |
| 1554 |
|
| 1555 |
// CHECK-LABEL: llvm.func @string_lit0 |
| 1556 |
// CHECK: %{{.*}} = llvm.mlir.constant("Hello, World!") : !llvm.array<13 x i8> |
| 1557 |
|
| 1558 |
func.func @string_lit1() { |
| 1559 |
%2 = fir.string_lit [158, 2345](2) : !fir.char<2> |
| 1560 |
return |
| 1561 |
} |
| 1562 |
|
| 1563 |
// CHECK-LABEL: llvm.func @string_lit1 |
| 1564 |
// %{{.*}} = llvm.mlir.constant(dense<[158, 2345]> : vector<2xi16>) : !llvm.array<2 x i16> |
| 1565 |
|
| 1566 |
// ----- |
| 1567 |
|
| 1568 |
// Test must be dead conversion. |
| 1569 |
|
| 1570 |
func.func @dead_shift() { |
| 1571 |
%c0 = arith.constant 0 : index |
| 1572 |
%0 = fir.shift %c0 : (index) -> !fir.shift<1> |
| 1573 |
return |
| 1574 |
} |
| 1575 |
|
| 1576 |
// CHECK-LABEL: llvm.func @dead_shift |
| 1577 |
// CHECK-NOT: fir.shift |
| 1578 |
// CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}} |
| 1579 |
// CHECK-NEXT: llvm.return |
| 1580 |
|
| 1581 |
func.func @dead_shape() { |
| 1582 |
%c0 = arith.constant 0 : index |
| 1583 |
%0 = fir.shape %c0 : (index) -> !fir.shape<1> |
| 1584 |
return |
| 1585 |
} |
| 1586 |
|
| 1587 |
// CHECK-LABEL: llvm.func @dead_shape |
| 1588 |
// CHECK-NOT: fir.shape |
| 1589 |
// CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}} |
| 1590 |
// CHECK-NEXT: llvm.return |
| 1591 |
|
| 1592 |
func.func @dead_shapeshift() { |
| 1593 |
%c0 = arith.constant 0 : index |
| 1594 |
%0 = fir.shape_shift %c0, %c0 : (index, index) -> !fir.shapeshift<1> |
| 1595 |
return |
| 1596 |
} |
| 1597 |
|
| 1598 |
// CHECK-LABEL: llvm.func @dead_shapeshift |
| 1599 |
// CHECK-NOT: fir.shape_shift |
| 1600 |
// CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}} |
| 1601 |
// CHECK-NEXT: llvm.return |
| 1602 |
|
| 1603 |
func.func @dead_slice() { |
| 1604 |
%c0 = arith.constant 0 : index |
| 1605 |
%0 = fir.slice %c0, %c0, %c0 : (index, index, index) -> !fir.slice<1> |
| 1606 |
return |
| 1607 |
} |
| 1608 |
|
| 1609 |
// CHECK-LABEL: llvm.func @dead_slice |
| 1610 |
// CHECK-NOT: fir.slice |
| 1611 |
// CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}} |
| 1612 |
// CHECK-NEXT: llvm.return |
| 1613 |
|
| 1614 |
// ----- |
| 1615 |
|
| 1616 |
// Test `fir.box_tdesc` conversion. |
| 1617 |
|
| 1618 |
func.func @box_tdesc(%arg0: !fir.box<!fir.type<dtdesc{a:i32}>>) { |
| 1619 |
%0 = fir.box_tdesc %arg0 : (!fir.box<!fir.type<dtdesc{a:i32}>>) -> !fir.tdesc<!fir.type<dtdesc{a:i32}>> |
| 1620 |
return |
| 1621 |
} |
| 1622 |
|
| 1623 |
// CHECK-LABEL: llvm.func @box_tdesc( |
| 1624 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) { |
| 1625 |
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> |
| 1626 |
// CHECK: %[[LOAD:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> !llvm.ptr |
| 1627 |
|
| 1628 |
// ----- |
| 1629 |
|
| 1630 |
// Test `fir.embox` conversion. |
| 1631 |
|
| 1632 |
// Check basic creation of a descriptor and insertion of values. |
| 1633 |
// The indices used to insert values into the descriptor correspond the |
| 1634 |
// position of the fields in the descriptor as defined in `CFI_cdesc_t` in |
| 1635 |
// flang/ISO_Fortran_binding.h. |
| 1636 |
|
| 1637 |
func.func @embox0(%arg0: !fir.ref<!fir.array<100xi32>>) { |
| 1638 |
%0 = fir.embox %arg0() : (!fir.ref<!fir.array<100xi32>>) -> !fir.box<!fir.array<100xi32>> |
| 1639 |
return |
| 1640 |
} |
| 1641 |
|
| 1642 |
// CHECK-LABEL: func @embox0( |
| 1643 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 1644 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1645 |
// GENERIC: %[[ALLOCA:.*]] = llvm.alloca %[[C1]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 1646 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[C1]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 1647 |
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1648 |
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32 |
| 1649 |
// CHECK: %[[I64_ELEM_SIZE:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 1650 |
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1651 |
// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[I64_ELEM_SIZE]], %[[DESC]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1652 |
// CHECK: %[[CFI_VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 1653 |
// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[DESC0]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1654 |
// CHECK: %[[RANK:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1655 |
// CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 1656 |
// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[RANK_I8]], %[[DESC1]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1657 |
// CHECK: %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 |
| 1658 |
// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[DESC2]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1659 |
// CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1660 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 |
| 1661 |
// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[DESC3]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1662 |
// CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1663 |
// CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 |
| 1664 |
// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[DESC4]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1665 |
// CHECK: %[[DESC6:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC5]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1666 |
// CHECK: llvm.store %[[DESC6]], %[[ALLOCA]] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>, !llvm.ptr |
| 1667 |
|
| 1668 |
// Check `fir.embox` in a `fir.global`. Descriptors created by `fir.embox` |
| 1669 |
// conversion are not generating `alloca` instructions. This test make sure of |
| 1670 |
// that. |
| 1671 |
|
| 1672 |
fir.global @box_global : !fir.ref<!fir.array<?xi32>> { |
| 1673 |
%arr = fir.zero_bits !fir.ref<!fir.array<?xi32>> |
| 1674 |
%0 = arith.constant 0 : index |
| 1675 |
%3 = fir.embox %arr: (!fir.ref<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>> |
| 1676 |
fir.has_value %arr : !fir.ref<!fir.array<?xi32>> |
| 1677 |
} |
| 1678 |
|
| 1679 |
// CHECK-LABEL: llvm.mlir.global external @box_global |
| 1680 |
// CHECK-NOT: llvm.alloca |
| 1681 |
|
| 1682 |
// Check `fir.embox` conversion of a POINTER entity. Make sure that the |
| 1683 |
// attribute in the descriptor is set to 1 (value of CFI_attribute_pointer |
| 1684 |
// in flang/ISO_Fortran_binding.h). |
| 1685 |
|
| 1686 |
func.func @embox_pointer(%arg0: !fir.ref<i32>) { |
| 1687 |
%0 = fir.embox %arg0 : (!fir.ref<i32>) -> !fir.box<!fir.ptr<i32>> |
| 1688 |
return |
| 1689 |
} |
| 1690 |
|
| 1691 |
// CHECK-LABEL: llvm.func @embox_pointer |
| 1692 |
// Check 1st 1 constant to skip it. |
| 1693 |
// CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32 |
| 1694 |
// CHECK: %[[CFI_ATTR_POINTER:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1695 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_POINTER]] : i32 to i8 |
| 1696 |
// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1697 |
|
| 1698 |
// Check `fir.embox` conversion of an ALLOCATABLE entity. Make sure that the |
| 1699 |
// attribute in the descriptor is set to 2 (value of CFI_attribute_allocatable |
| 1700 |
// in flang/ISO_Fortran_binding.h). |
| 1701 |
|
| 1702 |
func.func @embox_allocatable(%arg0: !fir.heap<!fir.array<?x!fir.char<1,10>>>) { |
| 1703 |
%0 = fir.embox %arg0 : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>> |
| 1704 |
return |
| 1705 |
} |
| 1706 |
|
| 1707 |
// CHECK-LABEL: llvm.func @embox_allocatable |
| 1708 |
// CHECK: %[[CFI_ATTR_ALLOCATABLE:.*]] = llvm.mlir.constant(2 : i32) : i32 |
| 1709 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_ALLOCATABLE]] : i32 to i8 |
| 1710 |
// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1711 |
|
| 1712 |
// Check `fir.embox` conversion of a type code. |
| 1713 |
|
| 1714 |
func.func @embox_typecode0(%arg0: !fir.ref<i64>) { |
| 1715 |
%0 = fir.embox %arg0 : (!fir.ref<i64>) -> !fir.box<!fir.ptr<i64>> |
| 1716 |
return |
| 1717 |
} |
| 1718 |
|
| 1719 |
// CHECK-LABEL: llvm.func @embox_typecode0 |
| 1720 |
// CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(10 : i32) : i32 |
| 1721 |
// CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8 |
| 1722 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1723 |
|
| 1724 |
func.func @embox_typecode1(%arg0: !fir.ref<f32>) { |
| 1725 |
%0 = fir.embox %arg0 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>> |
| 1726 |
return |
| 1727 |
} |
| 1728 |
|
| 1729 |
// CHECK-LABEL: llvm.func @embox_typecode1 |
| 1730 |
// CHECK: %[[TYPE_CODE_F32:.*]] = llvm.mlir.constant(27 : i32) : i32 |
| 1731 |
// CHECK: %[[TYPE_CODE_F32_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8 |
| 1732 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F32_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1733 |
|
| 1734 |
func.func @embox_typecode2(%arg0: !fir.ref<f128>) { |
| 1735 |
%0 = fir.embox %arg0 : (!fir.ref<f128>) -> !fir.box<!fir.ptr<f128>> |
| 1736 |
return |
| 1737 |
} |
| 1738 |
|
| 1739 |
// CHECK-LABEL: llvm.func @embox_typecode2 |
| 1740 |
// CHECK: %[[TYPE_CODE_F128:.*]] = llvm.mlir.constant(31 : i32) : i32 |
| 1741 |
// CHECK: %[[TYPE_CODE_F128_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8 |
| 1742 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F128_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1743 |
|
| 1744 |
func.func @embox_typecode3(%arg0: !fir.ref<complex<f32>>) { |
| 1745 |
%0 = fir.embox %arg0 : (!fir.ref<complex<f32>>) -> !fir.box<!fir.ptr<complex<f32>>> |
| 1746 |
return |
| 1747 |
} |
| 1748 |
|
| 1749 |
// CHECK-LABEL: llvm.func @embox_typecode3 |
| 1750 |
// CHECK: %[[TYPE_CODE_CPLX4:.*]] = llvm.mlir.constant(34 : i32) : i32 |
| 1751 |
// CHECK: %[[TYPE_CODE_CPLX4_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8 |
| 1752 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_CPLX4_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1753 |
|
| 1754 |
func.func @embox_typecode4(%arg0: !fir.ref<!fir.logical<1>>) { |
| 1755 |
%0 = fir.embox %arg0 : (!fir.ref<!fir.logical<1>>) -> !fir.box<!fir.ptr<!fir.logical<1>>> |
| 1756 |
return |
| 1757 |
} |
| 1758 |
|
| 1759 |
// CHECK-LABEL: llvm.func @embox_typecode4 |
| 1760 |
// CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(39 : i32) : i32 |
| 1761 |
// CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8 |
| 1762 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> |
| 1763 |
|
| 1764 |
// ----- |
| 1765 |
|
| 1766 |
// Test `fir.embox` conversion. This test creates a global so it needs to be |
| 1767 |
// split from others. |
| 1768 |
|
| 1769 |
// Check descriptor for a derived type. Check that the f18Addendum flag is set |
| 1770 |
// to 1 meaning the addendum is present (true) and the addendum values are |
| 1771 |
// inserted. |
| 1772 |
|
| 1773 |
fir.global linkonce @_QMtest_dinitE.dt.tseq constant : i8 |
| 1774 |
|
| 1775 |
func.func @embox1(%arg0: !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) { |
| 1776 |
%0 = fir.embox %arg0() : (!fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>> |
| 1777 |
return |
| 1778 |
} |
| 1779 |
|
| 1780 |
// CHECK-COMDAT: llvm.mlir.global linkonce constant @_QMtest_dinitE.dt.tseq() comdat(@__llvm_comdat::@_QMtest_dinitE.dt.tseq) {addr_space = 0 : i32} : i8 |
| 1781 |
// CHECK-NO-COMDAT: llvm.mlir.global linkonce constant @_QMtest_dinitE.dt.tseq() {addr_space = 0 : i32} : i8 |
| 1782 |
// CHECK-LABEL: llvm.func @embox1 |
| 1783 |
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(42 : i32) : i32 |
| 1784 |
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 1785 |
// CHECK: %{{.*}} = llvm.insertvalue %[[VERSION]], %{{.*}}[2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)> |
| 1786 |
// CHECK: %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 |
| 1787 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> |
| 1788 |
// CHECK: %[[TDESC:.*]] = llvm.mlir.addressof @_QMtest_dinitE.dt.tseq : !llvm.ptr |
| 1789 |
// CHECK: %{{.*}} = llvm.insertvalue %[[TDESC]], %{{.*}}[7] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> |
| 1790 |
|
| 1791 |
// ----- |
| 1792 |
|
| 1793 |
// Test `fir.field_index` |
| 1794 |
|
| 1795 |
func.func @field_index_static_size_1_elem() -> () { |
| 1796 |
%1 = fir.field_index i, !fir.type<t1{i:i32}> |
| 1797 |
return |
| 1798 |
} |
| 1799 |
|
| 1800 |
// CHECK-LABEL: @field_index_static_size_1_elem |
| 1801 |
// CHECK-NEXT: %{{.*}} = llvm.mlir.constant(0 : i32) : i32 |
| 1802 |
// CHECK-NEXT: llvm.return |
| 1803 |
|
| 1804 |
func.func @field_index_static_size_3_elems() -> () { |
| 1805 |
%1 = fir.field_index k, !fir.type<t2{i:i32, j:f32, k:i8}> |
| 1806 |
return |
| 1807 |
} |
| 1808 |
|
| 1809 |
// CHECK-LABEL: @field_index_static_size_3_elems |
| 1810 |
// CHECK-NEXT: %{{.*}} = llvm.mlir.constant(2 : i32) : i32 |
| 1811 |
// CHECK-NEXT: llvm.return |
| 1812 |
|
| 1813 |
// When converting `fir.field_index` for a dynamically sized record, the |
| 1814 |
// offset will be calculated at runtime by calling methods like the ones |
| 1815 |
// below. Note that these methods would normally be generated by the compiler. |
| 1816 |
func.func private @custom_typeP.field_1.offset() -> i32 |
| 1817 |
func.func private @custom_typeP.field_2.offset() -> i32 |
| 1818 |
|
| 1819 |
func.func @field_index_dynamic_size() -> () { |
| 1820 |
%1 = fir.field_index field_1, !fir.type<custom_type(l:i32){field_1:i32, field_2:!fir.array<?xf32>}> |
| 1821 |
%2 = fir.field_index field_2, !fir.type<custom_type(l:i32){field_1:i32, field_2:!fir.array<?xf32>}> |
| 1822 |
return |
| 1823 |
} |
| 1824 |
|
| 1825 |
// CHECK-LABEL: @field_index_dynamic_size |
| 1826 |
// CHECK-NEXT: %{{.*}} = llvm.call @custom_typeP.field_1.offset() {field = 0 : i64} : () -> i32 |
| 1827 |
// CHECK-NEXT: %{{.*}} = llvm.call @custom_typeP.field_2.offset() {field = 1 : i64} : () -> i32 |
| 1828 |
// CHECK-NEXT: llvm.return |
| 1829 |
|
| 1830 |
// ----- |
| 1831 |
|
| 1832 |
// Check `fir.no_reassoc` conversion to LLVM IR dialect |
| 1833 |
|
| 1834 |
func.func @no_reassoc(%arg0: !fir.ref<i32>) { |
| 1835 |
%0 = fir.alloca i32 |
| 1836 |
%1 = fir.load %arg0 : !fir.ref<i32> |
| 1837 |
%2 = fir.no_reassoc %1 : i32 |
| 1838 |
fir.store %2 to %0 : !fir.ref<i32> |
| 1839 |
return |
| 1840 |
} |
| 1841 |
|
| 1842 |
// CHECK-LABEL: llvm.func @no_reassoc( |
| 1843 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) { |
| 1844 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1845 |
// GENERIC: %[[ALLOC:.*]] = llvm.alloca %[[C1]] x i32 : (i64) -> !llvm.ptr |
| 1846 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[C1]] x i32 : (i64) -> !llvm.ptr<5> |
| 1847 |
// AMDGPU: %[[ALLOC:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1848 |
// CHECK: %[[LOAD:.*]] = llvm.load %[[ARG0]] : !llvm.ptr -> i32 |
| 1849 |
// CHECK: llvm.store %[[LOAD]], %[[ALLOC]] : i32, !llvm.ptr |
| 1850 |
// CHECK: llvm.return |
| 1851 |
|
| 1852 |
// ----- |
| 1853 |
|
| 1854 |
// Test `fircg.ext_embox` conversion. |
| 1855 |
|
| 1856 |
// Check complete `fircg.ext_embox`. |
| 1857 |
|
| 1858 |
func.func @xembox0(%arg0: !fir.ref<!fir.array<?xi32>>) { |
| 1859 |
%c0 = arith.constant 0 : i64 |
| 1860 |
%0 = fircg.ext_embox %arg0(%c0) origin %c0[%c0, %c0, %c0] : (!fir.ref<!fir.array<?xi32>>, i64, i64, i64, i64, i64) -> !fir.box<!fir.array<?xi32>> |
| 1861 |
return |
| 1862 |
} |
| 1863 |
|
| 1864 |
// CHECK-LABEL: llvm.func @xembox0( |
| 1865 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 1866 |
// CHECK: %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1867 |
// GENERIC: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 1868 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 1869 |
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1870 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1871 |
// CHECK: %[[TYPE:.*]] = llvm.mlir.constant(9 : i32) : i32 |
| 1872 |
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 1873 |
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1874 |
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1875 |
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 1876 |
// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1877 |
// CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1878 |
// CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 1879 |
// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1880 |
// CHECK: %[[TYPE_I8:.*]] = llvm.trunc %[[TYPE]] : i32 to i8 |
| 1881 |
// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1882 |
// CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1883 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 |
| 1884 |
// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1885 |
// CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1886 |
// CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 |
| 1887 |
// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1888 |
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1889 |
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1890 |
// CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C0]], %[[C0]] : i64 |
| 1891 |
// CHECK: %[[DIM_OFFSET:.*]] = llvm.mul %[[ADJUSTED_OFFSET]], %[[ONE]] : i64 |
| 1892 |
// CHECK: %[[PTR_OFFSET:.*]] = llvm.add %[[DIM_OFFSET]], %[[ZERO]] : i64 |
| 1893 |
// CHECK: %[[EXTENT0:.*]] = llvm.sub %[[C0]], %[[C0]] : i64 |
| 1894 |
// CHECK: %[[EXTENT1:.*]] = llvm.add %[[EXTENT0]], %[[C0]] : i64 |
| 1895 |
// CHECK: %[[EXTENT2:.*]] = llvm.sdiv %[[EXTENT1]], %[[C0]] : i64 |
| 1896 |
// CHECK: %[[EXTENT_CMP:.*]] = llvm.icmp "sgt" %[[EXTENT2]], %[[ZERO]] : i64 |
| 1897 |
// CHECK: %[[EXTENT:.*]] = llvm.select %[[EXTENT_CMP]], %[[EXTENT2]], %[[ZERO]] : i1, i64 |
| 1898 |
// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1899 |
// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1900 |
// CHECK: %[[STRIDE:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0]] : i64 |
| 1901 |
// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1902 |
// CHECK: %[[PREV_DIM:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0]] : i64 |
| 1903 |
// CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ONE]], %[[C0]] : i64 |
| 1904 |
// CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARG0]][%[[PTR_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 1905 |
// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[BASE_PTR]], %[[BOX9]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1906 |
// CHECK: llvm.store %[[BOX10]], %[[ALLOCA]] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>, !llvm.ptr |
| 1907 |
|
| 1908 |
// Test i32 shape/shift/slice: |
| 1909 |
func.func @xembox0_i32(%arg0: !fir.ref<!fir.array<?xi32>>) { |
| 1910 |
%c0 = arith.constant 0 : i32 |
| 1911 |
%c0_i64 = arith.constant 0 : i64 |
| 1912 |
%0 = fircg.ext_embox %arg0(%c0) origin %c0[%c0, %c0, %c0] : (!fir.ref<!fir.array<?xi32>>, i32, i32, i32, i32, i32) -> !fir.box<!fir.array<?xi32>> |
| 1913 |
return |
| 1914 |
} |
| 1915 |
// CHECK-LABEL: llvm.func @xembox0_i32( |
| 1916 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 1917 |
// CHECK: %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1918 |
// GENERIC: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 1919 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 1920 |
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 1921 |
// CHECK: %[[C0_I32:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1922 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1923 |
// CHECK: %[[TYPE:.*]] = llvm.mlir.constant(9 : i32) : i32 |
| 1924 |
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 1925 |
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1926 |
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1927 |
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 1928 |
// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1929 |
// CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 1930 |
// CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 1931 |
// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1932 |
// CHECK: %[[TYPE_I8:.*]] = llvm.trunc %[[TYPE]] : i32 to i8 |
| 1933 |
// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1934 |
// CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1935 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 |
| 1936 |
// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1937 |
// CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 1938 |
// CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 |
| 1939 |
// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1940 |
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1941 |
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 1942 |
// CHECK: %[[C0_1:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1943 |
// CHECK: %[[C0_2:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1944 |
// CHECK: %[[C0_3:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1945 |
// CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C0_2]], %[[C0_3]] : i64 |
| 1946 |
// CHECK: %[[DIM_OFFSET:.*]] = llvm.mul %[[ADJUSTED_OFFSET]], %[[ONE]] : i64 |
| 1947 |
// CHECK: %[[PTR_OFFSET:.*]] = llvm.add %[[DIM_OFFSET]], %[[ZERO]] : i64 |
| 1948 |
// CHECK: %[[C0_4:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1949 |
// CHECK: %[[C0_5:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1950 |
// CHECK: %[[C0_6:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1951 |
// CHECK: %[[EXTENT0:.*]] = llvm.sub %[[C0_5]], %[[C0_4]] : i64 |
| 1952 |
// CHECK: %[[EXTENT1:.*]] = llvm.add %[[EXTENT0]], %[[C0_6]] : i64 |
| 1953 |
// CHECK: %[[EXTENT2:.*]] = llvm.sdiv %[[EXTENT1]], %[[C0_6]] : i64 |
| 1954 |
// CHECK: %[[EXTENT_CMP:.*]] = llvm.icmp "sgt" %[[EXTENT2]], %[[ZERO]] : i64 |
| 1955 |
// CHECK: %[[EXTENT:.*]] = llvm.select %[[EXTENT_CMP]], %[[EXTENT2]], %[[ZERO]] : i1, i64 |
| 1956 |
// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1957 |
// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1958 |
// CHECK: %[[C0_7:.*]] = llvm.sext %[[C0_I32]] : i32 to i64 |
| 1959 |
// CHECK: %[[STRIDE:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0_7]] : i64 |
| 1960 |
// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1961 |
// CHECK: %[[PREV_DIM:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0_1]] : i64 |
| 1962 |
// CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ONE]], %[[C0_1]] : i64 |
| 1963 |
// CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARG0]][%[[PTR_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 1964 |
// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[BASE_PTR]], %[[BOX9]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1965 |
// CHECK: llvm.store %[[BOX10]], %[[ALLOCA]] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>, !llvm.ptr |
| 1966 |
|
| 1967 |
// Check adjustment of element scaling factor. |
| 1968 |
|
| 1969 |
func.func @xembox1(%arg0: !fir.ref<!fir.array<?x!fir.char<1, 10>>>) { |
| 1970 |
%c0 = arith.constant 0 : i64 |
| 1971 |
%0 = fircg.ext_embox %arg0(%c0) origin %c0[%c0, %c0, %c0] : (!fir.ref<!fir.array<?x!fir.char<1, 10>>>, i64, i64, i64, i64, i64) -> !fir.box<!fir.array<?x!fir.char<1, 10>>> |
| 1972 |
return |
| 1973 |
} |
| 1974 |
|
| 1975 |
// CHECK-LABEL: llvm.func @xembox1(%{{.*}}: !llvm.ptr) { |
| 1976 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 1977 |
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(10 : i64) : i64 |
| 1978 |
// CHECK: %{{.*}} = llvm.insertvalue %[[ELEM_LEN_I64]], %{{.*}}[1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 1979 |
// CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0]] : i64 |
| 1980 |
|
| 1981 |
// Fortran realistic use case extracted from the following snippet: |
| 1982 |
// |
| 1983 |
// ``` |
| 1984 |
// subroutine sb(n,sh1,sh2) |
| 1985 |
// integer::n,sh1,sh2 |
| 1986 |
// double precision::arr(sh1:n,sh2:n) |
| 1987 |
// call xb(arr(2:n,4:n)) |
| 1988 |
// end subroutine |
| 1989 |
// ``` |
| 1990 |
|
| 1991 |
// N is the upperbound, sh1 and sh2 are the shifts or lowerbounds |
| 1992 |
func.func @_QPsb(%N: index, %sh1: index, %sh2: index) { |
| 1993 |
%c4 = arith.constant 4 : index |
| 1994 |
%c1 = arith.constant 1 : index |
| 1995 |
%c2 = arith.constant 2 : index |
| 1996 |
// Calculate nelems in dim1 |
| 1997 |
%n1_tmp = arith.subi %N, %sh1 : index |
| 1998 |
%n1 = arith.addi %n1_tmp, %c1 : index |
| 1999 |
// Calculate nelems in dim2 |
| 2000 |
%n2_tmp = arith.subi %N, %sh2 : index |
| 2001 |
%n2 = arith.addi %n2_tmp, %c1 : index |
| 2002 |
%arr = fir.alloca !fir.array<?x?xf64>, %n1, %n2 {bindc_name = "arr", uniq_name = "_QFsbEarr"} |
| 2003 |
%box = fircg.ext_embox %arr(%n1, %n2) origin %sh1, %sh2[%c2, %N, %c1, %c4, %N, %c1] : (!fir.ref<!fir.array<?x?xf64>>, index, index, index, index, index, index, index, index, index, index) -> !fir.box<!fir.array<?x?xf64>> |
| 2004 |
fir.call @_QPxb(%box) : (!fir.box<!fir.array<?x?xf64>>) -> () |
| 2005 |
return |
| 2006 |
} |
| 2007 |
func.func private @_QPxb(!fir.box<!fir.array<?x?xf64>>) |
| 2008 |
|
| 2009 |
// CHECK-LABEL: llvm.func @_QPsb( |
| 2010 |
// CHECK-SAME: %[[N:.*]]: i64, %[[SH1:.*]]: i64, %[[SH2:.*]]: i64) { |
| 2011 |
// CHECK: %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2012 |
// GENERIC: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 2013 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 2014 |
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 2015 |
// CHECK: %[[C4:.*]] = llvm.mlir.constant(4 : index) : i64 |
| 2016 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64 |
| 2017 |
// CHECK: %[[C2:.*]] = llvm.mlir.constant(2 : index) : i64 |
| 2018 |
// CHECK: %[[N1_TMP:.*]] = llvm.sub %[[N]], %[[SH1]] : i64 |
| 2019 |
// CHECK: %[[N1:.*]] = llvm.add %[[N1_TMP]], %[[C1]] : i64 |
| 2020 |
// CHECK: %[[N2_TMP:.*]] = llvm.sub %[[N]], %[[SH2]] : i64 |
| 2021 |
// CHECK: %[[N2:.*]] = llvm.add %[[N2_TMP]], %[[C1]] : i64 |
| 2022 |
// CHECK: %[[C1_0:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2023 |
// CHECK: %[[ARR_SIZE_TMP1:.*]] = llvm.mul %[[N1]], %[[C1_0]] : i64 |
| 2024 |
// CHECK: %[[ARR_SIZE:.*]] = llvm.mul %[[ARR_SIZE_TMP1]], %[[N2]] : i64 |
| 2025 |
// GENERIC: %[[ARR:.*]] = llvm.alloca %[[ARR_SIZE]] x f64 {bindc_name = "arr"} : (i64) -> !llvm.ptr |
| 2026 |
// AMDGPU: %[[AR:.*]] = llvm.alloca %[[ARR_SIZE]] x f64 {bindc_name = "arr"} : (i64) -> !llvm.ptr<5> |
| 2027 |
// AMDGPU: %[[ARR:.*]] = llvm.addrspacecast %[[AR]] : !llvm.ptr<5> to !llvm.ptr |
| 2028 |
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(28 : i32) : i32 |
| 2029 |
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(8 : i64) : i64 |
| 2030 |
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2031 |
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2032 |
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 2033 |
// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2034 |
// CHECK: %[[RANK:.*]] = llvm.mlir.constant(2 : i32) : i32 |
| 2035 |
// CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 2036 |
// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2037 |
// CHECK: %[[TYPE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 |
| 2038 |
// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2039 |
// CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 2040 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 |
| 2041 |
// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2042 |
// CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 2043 |
// CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 |
| 2044 |
// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2045 |
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2046 |
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2047 |
// CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C2]], %[[SH1]] : i64 |
| 2048 |
// CHECK: %[[DIM_OFFSET:.*]] = llvm.mul %[[ADJUSTED_OFFSET]], %[[ONE]] : i64 |
| 2049 |
// CHECK: %[[PTR_OFFSET:.*]] = llvm.add %[[DIM_OFFSET]], %[[ZERO]] : i64 |
| 2050 |
// CHECK: %[[EXTENT0:.*]] = llvm.sub %[[ARG0]], %[[C2]] : i64 |
| 2051 |
// CHECK: %[[EXTENT1:.*]] = llvm.add %[[EXTENT0]], %[[C1]] : i64 |
| 2052 |
// CHECK: %[[EXTENT2:.*]] = llvm.sdiv %[[EXTENT1]], %[[C1]] : i64 |
| 2053 |
// CHECK: %[[EXTENT_CMP:.*]] = llvm.icmp "sgt" %[[EXTENT2]], %[[ZERO]] : i64 |
| 2054 |
// CHECK: %[[EXTENT:.*]] = llvm.select %[[EXTENT_CMP]], %[[EXTENT2]], %[[ZERO]] : i1, i64 |
| 2055 |
// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2056 |
// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2057 |
// CHECK: %[[STRIDE:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C1]] : i64 |
| 2058 |
// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2059 |
// CHECK: %[[PREV_DIM:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[N1]] : i64 |
| 2060 |
// CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ONE]], %[[N1]] : i64 |
| 2061 |
// CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C4]], %[[SH2]] : i64 |
| 2062 |
// CHECK: %[[DIM_OFFSET:.*]] = llvm.mul %[[ADJUSTED_OFFSET]], %[[PREV_PTROFF]] : i64 |
| 2063 |
// CHECK: %[[PTR_OFFSET0:.*]] = llvm.add %[[DIM_OFFSET]], %[[PTR_OFFSET]] : i64 |
| 2064 |
// CHECK: %[[EXT_SUB:.*]] = llvm.sub %[[N]], %[[C4]] : i64 |
| 2065 |
// CHECK: %[[EXT_ADD:.*]] = llvm.add %[[EXT_SUB]], %[[C1]] : i64 |
| 2066 |
// CHECK: %[[EXT_SDIV:.*]] = llvm.sdiv %[[EXT_ADD]], %[[C1]] : i64 |
| 2067 |
// CHECK: %[[EXT_ICMP:.*]] = llvm.icmp "sgt" %[[EXT_SDIV]], %[[ZERO]] : i64 |
| 2068 |
// CHECK: %[[EXT_SELECT:.*]] = llvm.select %[[EXT_ICMP]], %[[EXT_SDIV]], %[[ZERO]] : i1, i64 |
| 2069 |
// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ONE]], %[[BOX9]][7, 1, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2070 |
// CHECK: %[[BOX11:.*]] = llvm.insertvalue %[[EXT_SELECT]], %[[BOX10]][7, 1, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2071 |
// CHECK: %[[STRIDE_MUL:.*]] = llvm.mul %[[PREV_DIM]], %[[C1]] : i64 |
| 2072 |
// CHECK: %[[BOX12:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX11]][7, 1, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2073 |
// CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARR]][%[[PTR_OFFSET0]]] : (!llvm.ptr, i64) -> !llvm.ptr, f64 |
| 2074 |
// CHECK: %[[BOX13:.*]] = llvm.insertvalue %[[BASE_PTR]], %[[BOX12]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2075 |
// CHECK: llvm.store %[[BOX13]], %[[ALLOCA]] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>, !llvm.ptr |
| 2076 |
|
| 2077 |
// Conversion with a subcomponent. |
| 2078 |
|
| 2079 |
func.func @_QPtest_dt_slice() { |
| 2080 |
%c20 = arith.constant 20 : index |
| 2081 |
%c1_i64 = arith.constant 1 : i64 |
| 2082 |
%c10_i64 = arith.constant 10 : i64 |
| 2083 |
%c2_i64 = arith.constant 2 : i64 |
| 2084 |
%0 = fir.alloca i32 {bindc_name = "v", uniq_name = "_QFtest_dt_sliceEv"} |
| 2085 |
%1 = fir.alloca !fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>> {bindc_name = "x", uniq_name = "_QFtest_dt_sliceEx"} |
| 2086 |
%2 = fir.field_index i, !fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}> |
| 2087 |
%5 = fircg.ext_embox %1(%c20)[%c1_i64, %c10_i64, %c2_i64] path %2 : (!fir.ref<!fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>>, index, i64, i64, i64, !fir.field) -> !fir.box<!fir.array<?xi32>> |
| 2088 |
fir.call @_QPtest_dt_callee(%5) : (!fir.box<!fir.array<?xi32>>) -> () |
| 2089 |
return |
| 2090 |
} |
| 2091 |
func.func private @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>) |
| 2092 |
|
| 2093 |
// CHECK-LABEL: llvm.func @_QPtest_dt_slice |
| 2094 |
// CHECK: %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2095 |
// GENERIC: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 2096 |
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 2097 |
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 2098 |
// CHECK: %[[ALLOCA_SIZE_X:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2099 |
// GENERIC: %[[X:.*]] = llvm.alloca %[[ALLOCA_SIZE_X]] x !llvm.array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>> {bindc_name = "x"} : (i64) -> !llvm.ptr |
| 2100 |
// AMDGPU: %[[AC:.*]] = llvm.alloca %[[ALLOCA_SIZE_X]] x !llvm.array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>> {bindc_name = "x"} : (i64) -> !llvm.ptr<5> |
| 2101 |
// AMDGPU: %[[X:.*]] = llvm.addrspacecast %[[AC]] : !llvm.ptr<5> to !llvm.ptr |
| 2102 |
// CHECK: %[[ALLOCA_SIZE_V:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2103 |
// GENERIC: %[[V:.*]] = llvm.alloca %[[ALLOCA_SIZE_V]] x i32 {bindc_name = "v"} : (i64) -> !llvm.ptr |
| 2104 |
// AMDGPU: %[[AB:.*]] = llvm.alloca %[[ALLOCA_SIZE_V]] x i32 {bindc_name = "v"} : (i64) -> !llvm.ptr<5> |
| 2105 |
// AMDGPU: %[[V:.*]] = llvm.addrspacecast %[[AB]] : !llvm.ptr<5> to !llvm.ptr |
| 2106 |
// CHECK: %[[C20:.*]] = llvm.mlir.constant(20 : index) : i64 |
| 2107 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2108 |
// CHECK: %[[C10:.*]] = llvm.mlir.constant(10 : i64) : i64 |
| 2109 |
// CHECK: %[[C2:.*]] = llvm.mlir.constant(2 : i64) : i64 |
| 2110 |
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32 |
| 2111 |
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 2112 |
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2113 |
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2114 |
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 2115 |
// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2116 |
// CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2117 |
// CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 2118 |
// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2119 |
// CHECK: %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 |
| 2120 |
// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2121 |
// CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 2122 |
// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 |
| 2123 |
// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2124 |
// CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 2125 |
// CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 |
| 2126 |
// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2127 |
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2128 |
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2129 |
// CHECK: %[[PTRTOINT_DTYPE_SIZE:.*]] = llvm.mlir.constant(8 : i64) : i64 |
| 2130 |
// CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C1]], %[[ONE]] : i64 |
| 2131 |
// CHECK: %[[EXT_SUB:.*]] = llvm.sub %[[C10]], %[[C1]] : i64 |
| 2132 |
// CHECK: %[[EXT_ADD:.*]] = llvm.add %[[EXT_SUB]], %[[C2]] : i64 |
| 2133 |
// CHECK: %[[EXT_SDIV:.*]] = llvm.sdiv %[[EXT_ADD]], %[[C2]] : i64 |
| 2134 |
// CHECK: %[[EXT_ICMP:.*]] = llvm.icmp "sgt" %[[EXT_SDIV]], %[[ZERO]] : i64 |
| 2135 |
// CHECK: %[[EXT_SELECT:.*]] = llvm.select %[[EXT_ICMP]], %[[EXT_SDIV]], %[[ZERO]] : i1, i64 |
| 2136 |
// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2137 |
// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXT_SELECT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2138 |
// CHECK: %[[STRIDE_MUL:.*]] = llvm.mul %[[PTRTOINT_DTYPE_SIZE]], %[[C2]] : i64 |
| 2139 |
// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2140 |
// CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[X]][%[[ZERO]], %[[ADJUSTED_OFFSET]], 0] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>> |
| 2141 |
// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[BASE_PTR]], %[[BOX9]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2142 |
// CHECK: llvm.store %[[BOX10]], %[[ALLOCA]] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>, !llvm.ptr |
| 2143 |
// CHECK: llvm.call @_QPtest_dt_callee(%[[ALLOCA]]) : (!llvm.ptr) -> () |
| 2144 |
|
| 2145 |
// Conversion with a subcomponent that indexes a 2d array field in a derived type. |
| 2146 |
|
| 2147 |
func.func @_QPtest_dt_slice2(%arg0: !fir.ref<!fir.array<2x!fir.type<_QPtest_dt_slice2Tt{a:!fir.array<2x3xi32>}>>>) { |
| 2148 |
%c0 = arith.constant 0 : index |
| 2149 |
%c1 = arith.constant 1 : index |
| 2150 |
%c2 = arith.constant 2 : index |
| 2151 |
%1 = fir.field_index a, !fir.type<_QPtest_dt_slice2Tt{a:!fir.array<2x3xi32>}> |
| 2152 |
%2 = fircg.ext_embox %arg0(%c2)[%c1, %c2, %c1] path %1, %c0, %c1 : (!fir.ref<!fir.array<2x!fir.type<_QPtest_dt_slice2Tt{a:!fir.array<2x3xi32>}>>>, index, index, index, index, !fir.field, index, index) -> !fir.box<!fir.array<2xi32>> |
| 2153 |
return |
| 2154 |
} |
| 2155 |
|
| 2156 |
// CHECK-LABEL: llvm.func @_QPtest_dt_slice2( |
| 2157 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) { |
| 2158 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64 |
| 2159 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64 |
| 2160 |
// CHECK: %[[C2:.*]] = llvm.mlir.constant(2 : index) : i64 |
| 2161 |
// CHECK: %[[C0_2:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2162 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][%[[C0_2]], {{.*}}, 0, %[[C1]], %[[C0]]] : (!llvm.ptr, i64, i64, i64, i64) -> !llvm.ptr, !llvm.array<2 x struct<"_QPtest_dt_slice2Tt", (array<3 x array<2 x i32>>)>> |
| 2163 |
// CHECK: return |
| 2164 |
// CHECK: } |
| 2165 |
|
| 2166 |
// ----- |
| 2167 |
|
| 2168 |
// Test `fircg.ext_array_coor` conversion. |
| 2169 |
|
| 2170 |
// Conversion with only shape and indice. |
| 2171 |
|
| 2172 |
func.func @ext_array_coor0(%arg0: !fir.ref<!fir.array<?xi32>>) { |
| 2173 |
%c0 = arith.constant 0 : i64 |
| 2174 |
%1 = fircg.ext_array_coor %arg0(%c0) <%c0> : (!fir.ref<!fir.array<?xi32>>, i64, i64) -> !fir.ref<i32> |
| 2175 |
return |
| 2176 |
} |
| 2177 |
|
| 2178 |
// CHECK-LABEL: llvm.func @ext_array_coor0( |
| 2179 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) |
| 2180 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2181 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2182 |
// CHECK: %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2183 |
// CHECK: %[[IDX:.*]] = llvm.sub %[[C0]], %[[C1]] overflow<nsw> : i64 |
| 2184 |
// CHECK: %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C1]] overflow<nsw> : i64 |
| 2185 |
// CHECK: %[[SC:.*]] = llvm.mul %[[DIFF0]], %[[C1]] overflow<nsw> : i64 |
| 2186 |
// CHECK: %[[OFFSET:.*]] = llvm.add %[[SC]], %[[C0_1]] overflow<nsw> : i64 |
| 2187 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2188 |
|
| 2189 |
// Conversion with shift and slice. |
| 2190 |
|
| 2191 |
func.func @ext_array_coor1(%arg0: !fir.ref<!fir.array<?xi32>>) { |
| 2192 |
%c0 = arith.constant 0 : i64 |
| 2193 |
%1 = fircg.ext_array_coor %arg0(%c0) origin %c0[%c0, %c0, %c0]<%c0> : (!fir.ref<!fir.array<?xi32>>, i64, i64, i64, i64, i64, i64) -> !fir.ref<i32> |
| 2194 |
return |
| 2195 |
} |
| 2196 |
|
| 2197 |
// CHECK-LABEL: llvm.func @ext_array_coor1( |
| 2198 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) |
| 2199 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2200 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2201 |
// CHECK: %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2202 |
// CHECK: %[[IDX:.*]] = llvm.sub %[[C0]], %[[C0]] overflow<nsw> : i64 |
| 2203 |
// CHECK: %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C0]] overflow<nsw> : i64 |
| 2204 |
// CHECK: %[[ADJ:.*]] = llvm.sub %[[C0]], %[[C0]] overflow<nsw> : i64 |
| 2205 |
// CHECK: %[[DIFF1:.*]] = llvm.add %[[DIFF0]], %[[ADJ]] overflow<nsw> : i64 |
| 2206 |
// CHECK: %[[STRIDE:.*]] = llvm.mul %[[DIFF1]], %[[C1]] overflow<nsw> : i64 |
| 2207 |
// CHECK: %[[OFFSET:.*]] = llvm.add %[[STRIDE]], %[[C0_1]] overflow<nsw> : i64 |
| 2208 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2209 |
|
| 2210 |
// Conversion for a dynamic length char. |
| 2211 |
|
| 2212 |
func.func @ext_array_coor2(%arg0: !fir.ref<!fir.array<?x!fir.char<1,?>>>) { |
| 2213 |
%c0 = arith.constant 0 : i64 |
| 2214 |
%1 = fircg.ext_array_coor %arg0(%c0) <%c0> : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, i64, i64) -> !fir.ref<i32> |
| 2215 |
return |
| 2216 |
} |
| 2217 |
|
| 2218 |
// CHECK-LABEL: llvm.func @ext_array_coor2( |
| 2219 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) |
| 2220 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2221 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2222 |
// CHECK: %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2223 |
// CHECK: %[[IDX:.*]] = llvm.sub %[[C0]], %[[C1]] overflow<nsw> : i64 |
| 2224 |
// CHECK: %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C1]] overflow<nsw> : i64 |
| 2225 |
// CHECK: %[[SC:.*]] = llvm.mul %[[DIFF0]], %[[C1]] overflow<nsw> : i64 |
| 2226 |
// CHECK: %[[OFFSET:.*]] = llvm.add %[[SC]], %[[C0_1]] overflow<nsw> : i64 |
| 2227 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2228 |
|
| 2229 |
// Conversion for a `fir.box`. |
| 2230 |
|
| 2231 |
func.func @ext_array_coor3(%arg0: !fir.box<!fir.array<?xi32>>) { |
| 2232 |
%c0 = arith.constant 0 : i64 |
| 2233 |
%1 = fircg.ext_array_coor %arg0(%c0) <%c0> : (!fir.box<!fir.array<?xi32>>, i64, i64) -> !fir.ref<i32> |
| 2234 |
return |
| 2235 |
} |
| 2236 |
|
| 2237 |
// CHECK-LABEL: llvm.func @ext_array_coor3( |
| 2238 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr) { |
| 2239 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2240 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2241 |
// CHECK: %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2242 |
// CHECK: %[[IDX:.*]] = llvm.sub %[[C0]], %[[C1]] overflow<nsw> : i64 |
| 2243 |
// CHECK: %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C1]] overflow<nsw> : i64 |
| 2244 |
// CHECK: %[[GEPSTRIDE:.*]] = llvm.getelementptr %[[ARG0]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2245 |
// CHECK: %[[LOADEDSTRIDE:.*]] = llvm.load %[[GEPSTRIDE]] : !llvm.ptr -> i64 |
| 2246 |
// CHECK: %[[SC:.*]] = llvm.mul %[[DIFF0]], %[[LOADEDSTRIDE]] overflow<nsw> : i64 |
| 2247 |
// CHECK: %[[OFFSET:.*]] = llvm.add %[[SC]], %[[C0_1]] overflow<nsw> : i64 |
| 2248 |
// CHECK: %[[GEPADDR:.*]] = llvm.getelementptr %[[ARG0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2249 |
// CHECK: %[[LOADEDADDR:.*]] = llvm.load %[[GEPADDR]] : !llvm.ptr -> !llvm.ptr |
| 2250 |
// CHECK: %[[GEPADDROFFSET:.*]] = llvm.getelementptr %[[LOADEDADDR]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2251 |
|
| 2252 |
// Conversion with non zero shift and slice. |
| 2253 |
|
| 2254 |
func.func @ext_array_coor4(%arg0: !fir.ref<!fir.array<100xi32>>) { |
| 2255 |
%c0 = arith.constant 0 : i64 |
| 2256 |
%c10 = arith.constant 10 : i64 |
| 2257 |
%c20 = arith.constant 20 : i64 |
| 2258 |
%c1 = arith.constant 1 : i64 |
| 2259 |
%1 = fircg.ext_array_coor %arg0(%c0) origin %c0[%c10, %c20, %c1]<%c1> : (!fir.ref<!fir.array<100xi32>>, i64, i64, i64, i64, i64, i64) -> !fir.ref<i32> |
| 2260 |
return |
| 2261 |
} |
| 2262 |
|
| 2263 |
// CHECK-LABEL: llvm.func @ext_array_coor4( |
| 2264 |
// CHECK: %[[ARG0:.*]]: !llvm.ptr) { |
| 2265 |
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2266 |
// CHECK: %[[C10:.*]] = llvm.mlir.constant(10 : i64) : i64 |
| 2267 |
// CHECK: %[[C20:.*]] = llvm.mlir.constant(20 : i64) : i64 |
| 2268 |
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2269 |
// CHECK: %[[C1_1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2270 |
// CHECK: %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2271 |
// CHECK: %[[IDX:.*]] = llvm.sub %[[C1]], %[[C0]] overflow<nsw> : i64 |
| 2272 |
// CHECK: %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C1]] overflow<nsw> : i64 |
| 2273 |
// CHECK: %[[ADJ:.*]] = llvm.sub %[[C10]], %[[C0]] overflow<nsw> : i64 |
| 2274 |
// CHECK: %[[DIFF1:.*]] = llvm.add %[[DIFF0]], %[[ADJ]] overflow<nsw> : i64 |
| 2275 |
// CHECK: %[[STRIDE:.*]] = llvm.mul %[[DIFF1]], %[[C1_1]] overflow<nsw> : i64 |
| 2276 |
// CHECK: %[[OFFSET:.*]] = llvm.add %[[STRIDE]], %[[C0_1]] overflow<nsw> : i64 |
| 2277 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2278 |
|
| 2279 |
// Conversion with index type shape and slice |
| 2280 |
|
| 2281 |
func.func @ext_array_coor5(%arg0: !fir.ref<!fir.array<?xi32>>, %idx1 : index, %idx2 : index, %idx3 : index, %idx4 : index, %idx5 : index) { |
| 2282 |
%1 = fircg.ext_array_coor %arg0(%idx1)[%idx2, %idx3, %idx4]<%idx5> : (!fir.ref<!fir.array<?xi32>>, index, index, index, index, index) -> !fir.ref<i32> |
| 2283 |
return |
| 2284 |
} |
| 2285 |
|
| 2286 |
// CHECK-LABEL: llvm.func @ext_array_coor5( |
| 2287 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: i64, %[[VAL_2:.*]]: i64, %[[VAL_3:.*]]: i64, %[[VAL_4:.*]]: i64, %[[VAL_5:.*]]: i64) { |
| 2288 |
// CHECK: %[[VAL_6:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2289 |
// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2290 |
// CHECK: %[[VAL_8:.*]] = llvm.sub %[[VAL_5]], %[[VAL_6]] overflow<nsw> : i64 |
| 2291 |
// CHECK: %[[VAL_9:.*]] = llvm.mul %[[VAL_8]], %[[VAL_4]] overflow<nsw> : i64 |
| 2292 |
// CHECK: %[[VAL_10:.*]] = llvm.sub %[[VAL_2]], %[[VAL_6]] overflow<nsw> : i64 |
| 2293 |
// CHECK: %[[VAL_11:.*]] = llvm.add %[[VAL_9]], %[[VAL_10]] overflow<nsw> : i64 |
| 2294 |
// CHECK: %[[VAL_12:.*]] = llvm.mul %[[VAL_11]], %[[VAL_6]] overflow<nsw> : i64 |
| 2295 |
// CHECK: %[[VAL_13:.*]] = llvm.add %[[VAL_12]], %[[VAL_7]] overflow<nsw> : i64 |
| 2296 |
// CHECK: %[[VAL_14:.*]] = llvm.mul %[[VAL_6]], %[[VAL_1]] overflow<nsw> : i64 |
| 2297 |
// CHECK: %[[VAL_16:.*]] = llvm.getelementptr %[[VAL_0]][%[[VAL_13]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2298 |
// CHECK: } |
| 2299 |
|
| 2300 |
// Conversion for 3-d array |
| 2301 |
|
| 2302 |
func.func @ext_array_coor6(%arg0: !fir.ref<!fir.array<?x?x?xi32>>, %idx1 : index, %idx2 : index, %idx3 : index, %idx4 : index, %idx5 : index) { |
| 2303 |
%1 = fircg.ext_array_coor %arg0(%idx1, %idx1, %idx1)[%idx2, %idx3, %idx4, %idx2, %idx3, %idx4, %idx2, %idx3, %idx4]<%idx5, %idx5, %idx5> : (!fir.ref<!fir.array<?x?x?xi32>>, index, index, index, index, index, index, index, index, index, index, index, index, index, index, index) -> !fir.ref<i32> |
| 2304 |
return |
| 2305 |
} |
| 2306 |
|
| 2307 |
// CHECK-LABEL: llvm.func @ext_array_coor6( |
| 2308 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: i64, %[[VAL_2:.*]]: i64, %[[VAL_3:.*]]: i64, %[[VAL_4:.*]]: i64, %[[VAL_5:.*]]: i64) { |
| 2309 |
// CHECK: %[[VAL_6:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2310 |
// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2311 |
// CHECK: %[[VAL_8:.*]] = llvm.sub %[[VAL_5]], %[[VAL_6]] overflow<nsw> : i64 |
| 2312 |
// CHECK: %[[VAL_9:.*]] = llvm.mul %[[VAL_8]], %[[VAL_4]] overflow<nsw> : i64 |
| 2313 |
// CHECK: %[[VAL_10:.*]] = llvm.sub %[[VAL_2]], %[[VAL_6]] overflow<nsw> : i64 |
| 2314 |
// CHECK: %[[VAL_11:.*]] = llvm.add %[[VAL_9]], %[[VAL_10]] overflow<nsw> : i64 |
| 2315 |
// CHECK: %[[VAL_12:.*]] = llvm.mul %[[VAL_11]], %[[VAL_6]] overflow<nsw> : i64 |
| 2316 |
// CHECK: %[[VAL_13:.*]] = llvm.add %[[VAL_12]], %[[VAL_7]] overflow<nsw> : i64 |
| 2317 |
// CHECK: %[[VAL_14:.*]] = llvm.mul %[[VAL_6]], %[[VAL_1]] overflow<nsw> : i64 |
| 2318 |
// CHECK: %[[VAL_15:.*]] = llvm.sub %[[VAL_5]], %[[VAL_6]] overflow<nsw> : i64 |
| 2319 |
// CHECK: %[[VAL_16:.*]] = llvm.mul %[[VAL_15]], %[[VAL_4]] overflow<nsw> : i64 |
| 2320 |
// CHECK: %[[VAL_17:.*]] = llvm.sub %[[VAL_2]], %[[VAL_6]] overflow<nsw> : i64 |
| 2321 |
// CHECK: %[[VAL_18:.*]] = llvm.add %[[VAL_16]], %[[VAL_17]] overflow<nsw> : i64 |
| 2322 |
// CHECK: %[[VAL_19:.*]] = llvm.mul %[[VAL_18]], %[[VAL_14]] overflow<nsw> : i64 |
| 2323 |
// CHECK: %[[VAL_20:.*]] = llvm.add %[[VAL_19]], %[[VAL_13]] overflow<nsw> : i64 |
| 2324 |
// CHECK: %[[VAL_21:.*]] = llvm.mul %[[VAL_14]], %[[VAL_1]] overflow<nsw> : i64 |
| 2325 |
// CHECK: %[[VAL_22:.*]] = llvm.sub %[[VAL_5]], %[[VAL_6]] overflow<nsw> : i64 |
| 2326 |
// CHECK: %[[VAL_23:.*]] = llvm.mul %[[VAL_22]], %[[VAL_4]] overflow<nsw> : i64 |
| 2327 |
// CHECK: %[[VAL_24:.*]] = llvm.sub %[[VAL_2]], %[[VAL_6]] overflow<nsw> : i64 |
| 2328 |
// CHECK: %[[VAL_25:.*]] = llvm.add %[[VAL_23]], %[[VAL_24]] overflow<nsw> : i64 |
| 2329 |
// CHECK: %[[VAL_26:.*]] = llvm.mul %[[VAL_25]], %[[VAL_21]] overflow<nsw> : i64 |
| 2330 |
// CHECK: %[[VAL_27:.*]] = llvm.add %[[VAL_26]], %[[VAL_20]] overflow<nsw> : i64 |
| 2331 |
// CHECK: %[[VAL_28:.*]] = llvm.mul %[[VAL_21]], %[[VAL_1]] overflow<nsw> : i64 |
| 2332 |
// CHECK: %[[VAL_30:.*]] = llvm.getelementptr %[[VAL_0]][%[[VAL_27]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2333 |
// CHECK: llvm.return |
| 2334 |
// CHECK: } |
| 2335 |
|
| 2336 |
// Conversion for derived type with type param |
| 2337 |
|
| 2338 |
func.func @ext_array_coor_dt_slice(%arg0: !fir.ref<!fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>>, %idx1 : index, %idx2 : index, %idx3 : index, %idx4 : index, %idx5 : index) { |
| 2339 |
%1 = fir.field_index i, !fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}> |
| 2340 |
%2 = fircg.ext_array_coor %arg0(%idx1)[%idx2, %idx3, %idx4] path %1 <%idx5>: (!fir.ref<!fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>>, index, index, index, index, !fir.field, index) -> !fir.ref<!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>> |
| 2341 |
return |
| 2342 |
} |
| 2343 |
|
| 2344 |
// CHECK-LABEL: llvm.func @ext_array_coor_dt_slice( |
| 2345 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: i64, %[[VAL_2:.*]]: i64, %[[VAL_3:.*]]: i64, %[[VAL_4:.*]]: i64, %[[VAL_5:.*]]: i64) { |
| 2346 |
// CHECK: %[[VAL_6:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 2347 |
// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2348 |
// CHECK: %[[VAL_8:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2349 |
// CHECK: %[[VAL_9:.*]] = llvm.sub %[[VAL_5]], %[[VAL_7]] overflow<nsw> : i64 |
| 2350 |
// CHECK: %[[VAL_10:.*]] = llvm.mul %[[VAL_9]], %[[VAL_4]] overflow<nsw> : i64 |
| 2351 |
// CHECK: %[[VAL_11:.*]] = llvm.sub %[[VAL_2]], %[[VAL_7]] overflow<nsw> : i64 |
| 2352 |
// CHECK: %[[VAL_12:.*]] = llvm.add %[[VAL_10]], %[[VAL_11]] overflow<nsw> : i64 |
| 2353 |
// CHECK: %[[VAL_13:.*]] = llvm.mul %[[VAL_12]], %[[VAL_7]] overflow<nsw> : i64 |
| 2354 |
// CHECK: %[[VAL_14:.*]] = llvm.add %[[VAL_13]], %[[VAL_8]] overflow<nsw> : i64 |
| 2355 |
// CHECK: %[[VAL_15:.*]] = llvm.mul %[[VAL_7]], %[[VAL_1]] overflow<nsw> : i64 |
| 2356 |
// CHECK: %[[VAL_17:.*]] = llvm.getelementptr %[[VAL_0]][%[[VAL_14]], 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"_QFtest_dt_sliceTt", (i32, i32)> |
| 2357 |
// CHECK: llvm.return |
| 2358 |
// CHECK: } |
| 2359 |
|
| 2360 |
// Conversion for derived type with an array field |
| 2361 |
|
| 2362 |
func.func @ext_array_coor_dt_slice2(%arg0: !fir.ref<!fir.array<2x!fir.type<_QFtest_dt_slice2Tt{a:!fir.array<2x3xi32>}>>>, %idx1 : index, %idx2 : index, %idx3 : index, %idx4 : index, %idx5 : index, %idx6 : index, %idx7 : index) { |
| 2363 |
%1 = fir.field_index a, !fir.type<_QFtest_dt_sliceT2t{a:!fir.array<2x3xi32>}> |
| 2364 |
%2 = fircg.ext_array_coor %arg0(%idx1)[%idx2, %idx3, %idx4] path %1, %idx5, %idx6 <%idx7> : (!fir.ref<!fir.array<2x!fir.type<_QFtest_dt_slice2Tt{a:!fir.array<2x3xi32>}>>>, index, index, index, index, !fir.field, index, index, index) -> !fir.ref<i32> |
| 2365 |
return |
| 2366 |
} |
| 2367 |
|
| 2368 |
// CHECK-LABEL: llvm.func @ext_array_coor_dt_slice2( |
| 2369 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr, %[[IDX1:.*]]: i64, %[[IDX2:.*]]: i64, %[[IDX3:.*]]: i64, %[[IDX4:.*]]: i64, %[[IDX5:.*]]: i64, %[[IDX6:.*]]: i64, %[[IDX7:.*]]: i64) { |
| 2370 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][%{{.*}}, 0, %[[IDX6]], %[[IDX5]]] : (!llvm.ptr, i64, i64, i64) -> !llvm.ptr, !llvm.struct<"_QFtest_dt_slice2Tt", (array<3 x array<2 x i32>>)> |
| 2371 |
// CHECK: llvm.return |
| 2372 |
// CHECK: } |
| 2373 |
|
| 2374 |
// ----- |
| 2375 |
|
| 2376 |
// Check `fircg.ext_rebox` conversion to LLVM IR dialect |
| 2377 |
|
| 2378 |
// Test applying slice on fir.box. Note that the slice is 1D where as the array is 2D. |
| 2379 |
// subroutine foo(x) |
| 2380 |
// real :: x(3:, 4:) |
| 2381 |
// call bar(x(5, 6:80:3)) |
| 2382 |
// end subroutine |
| 2383 |
|
| 2384 |
func.func private @bar1(!fir.box<!fir.array<?xf32>>) |
| 2385 |
func.func @test_rebox_1(%arg0: !fir.box<!fir.array<?x?xf32>>) { |
| 2386 |
%c2 = arith.constant 2 : index |
| 2387 |
%c3 = arith.constant 3 : index |
| 2388 |
%c4 = arith.constant 4 : index |
| 2389 |
%c5 = arith.constant 5 : index |
| 2390 |
%c6 = arith.constant 6 : index |
| 2391 |
%c80 = arith.constant 80 : index |
| 2392 |
%0 = fir.undefined index |
| 2393 |
%3 = fircg.ext_rebox %arg0 origin %c3, %c4[%c5, %0, %0, %c6, %c80, %c3] : (!fir.box<!fir.array<?x?xf32>>, index, index, index, index, index, index, index, index) -> !fir.box<!fir.array<?xf32>> |
| 2394 |
fir.call @bar1(%3) : (!fir.box<!fir.array<?xf32>>) -> () |
| 2395 |
return |
| 2396 |
} |
| 2397 |
//CHECK-LABEL: llvm.func @bar1 |
| 2398 |
//CHECK-LABEL: llvm.func @test_rebox_1 |
| 2399 |
//CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 2400 |
//CHECK: %[[ONE_1:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2401 |
//GENERIC: %[[RESULT_BOX_REF:.*]] = llvm.alloca %[[ONE_1]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 2402 |
//AMDGPU: %[[AA:.*]] = llvm.alloca %[[ONE_1]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 2403 |
//AMDGPU: %[[RESULT_BOX_REF:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 2404 |
//CHECK: %[[THREE:.*]] = llvm.mlir.constant(3 : index) : i64 |
| 2405 |
//CHECK: %[[FOUR:.*]] = llvm.mlir.constant(4 : index) : i64 |
| 2406 |
//CHECK: %[[FIVE:.*]] = llvm.mlir.constant(5 : index) : i64 |
| 2407 |
//CHECK: %[[SIX:.*]] = llvm.mlir.constant(6 : index) : i64 |
| 2408 |
//CHECK: %[[EIGHTY:.*]] = llvm.mlir.constant(80 : index) : i64 |
| 2409 |
//CHECK: %[[FLOAT_TYPE:.*]] = llvm.mlir.constant(27 : i32) : i32 |
| 2410 |
//CHECK: %[[ELEM_SIZE_I64:.*]] = llvm.mlir.constant(4 : i64) : i64 |
| 2411 |
//CHECK: %[[EXTRA_GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)> |
| 2412 |
//CHECK: %[[EXTRA:.*]] = llvm.load %[[EXTRA_GEP]] : !llvm.ptr -> i8 |
| 2413 |
//CHECK: %[[RBOX:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2414 |
//CHECK: %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE_I64]], %[[RBOX]][1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2415 |
//CHECK: %[[CFI_VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32 |
| 2416 |
//CHECK: %[[RBOX_TMP2:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[RBOX_TMP1]][2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2417 |
//CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2418 |
//CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 2419 |
//CHECK: %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2420 |
//CHECK: %[[FLOAT_TYPE_I8:.*]] = llvm.trunc %[[FLOAT_TYPE]] : i32 to i8 |
| 2421 |
//CHECK: %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[FLOAT_TYPE_I8]], %[[RBOX_TMP3]][4] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2422 |
//CHECK: %[[OTHER_ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 |
| 2423 |
//CHECK: %[[OTHER_ATTR_I8:.*]] = llvm.trunc %[[OTHER_ATTR]] : i32 to i8 |
| 2424 |
//CHECK: %[[RBOX_TMP5:.*]] = llvm.insertvalue %[[OTHER_ATTR_I8]], %[[RBOX_TMP4]][5] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2425 |
//CHECK: %[[MASK:.*]] = llvm.mlir.constant(254 : ui8) : i8 |
| 2426 |
//CHECK: %[[EXTRA_WITH_ADDENDUM_CORRECTION:.*]] = llvm.and %[[EXTRA]], %[[MASK]] : i8 |
| 2427 |
//CHECK: %[[RBOX_TMP6:.*]] = llvm.insertvalue %[[EXTRA_WITH_ADDENDUM_CORRECTION]], %[[RBOX_TMP5]][6] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2428 |
//CHECK: %[[DIM1_STRIDE_REF:.*]] = llvm.getelementptr %[[ARG0]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)> |
| 2429 |
//CHECK: %[[DIM1_STRIDE:.*]] = llvm.load %[[DIM1_STRIDE_REF]] : !llvm.ptr -> i64 |
| 2430 |
//CHECK: %[[DIM2_STRIDE_REF:.*]] = llvm.getelementptr %[[ARG0]][0, 7, 1, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)> |
| 2431 |
//CHECK: %[[DIM2_STRIDE:.*]] = llvm.load %[[DIM2_STRIDE_REF]] : !llvm.ptr -> i64 |
| 2432 |
//CHECK: %[[SOURCE_ARRAY_PTR:.*]] = llvm.getelementptr %[[ARG0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)> |
| 2433 |
//CHECK: %[[SOURCE_ARRAY:.*]] = llvm.load %[[SOURCE_ARRAY_PTR]] : !llvm.ptr -> !llvm.ptr |
| 2434 |
//CHECK: %[[ZERO_ELEMS:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2435 |
//CHECK: %[[DIM1_LB_DIFF:.*]] = llvm.sub %[[FIVE]], %[[THREE]] : i64 |
| 2436 |
//CHECK: %[[DIM1_LB_OFFSET:.*]] = llvm.mul %[[DIM1_LB_DIFF]], %[[DIM1_STRIDE]] : i64 |
| 2437 |
//CHECK: %[[RESULT_PTR_DIM1:.*]] = llvm.getelementptr %[[SOURCE_ARRAY]][%[[DIM1_LB_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2438 |
//CHECK: %[[DIM2_LB_DIFF:.*]] = llvm.sub %[[SIX]], %[[FOUR]] : i64 |
| 2439 |
//CHECK: %[[DIM2_LB_OFFSET:.*]] = llvm.mul %[[DIM2_LB_DIFF]], %[[DIM2_STRIDE]] : i64 |
| 2440 |
//CHECK: %[[RESULT_PTR:.*]] = llvm.getelementptr %[[RESULT_PTR_DIM1]][%[[DIM2_LB_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2441 |
//CHECK: %[[RESULT_UB_LB_DIFF:.*]] = llvm.sub %[[EIGHTY]], %[[SIX]] : i64 |
| 2442 |
//CHECK: %[[RESULT_UB_LB_DIFF_PLUS_STRIDE:.*]] = llvm.add %[[RESULT_UB_LB_DIFF]], %[[THREE]] : i64 |
| 2443 |
//CHECK: %[[RESULT_NELEMS_TMP:.*]] = llvm.sdiv %[[RESULT_UB_LB_DIFF_PLUS_STRIDE]], %[[THREE]] : i64 |
| 2444 |
//CHECK: %[[RESULT_IF_NON_ZERO:.*]] = llvm.icmp "sgt" %[[RESULT_NELEMS_TMP]], %[[ZERO_ELEMS]] : i64 |
| 2445 |
//CHECK: %[[RESULT_NELEMS:.*]] = llvm.select %[[RESULT_IF_NON_ZERO]], %[[RESULT_NELEMS_TMP]], %[[ZERO_ELEMS]] : i1, i64 |
| 2446 |
//CHECK: %[[RESULT_STRIDE:.*]] = llvm.mul %[[THREE]], %[[DIM2_STRIDE]] : i64 |
| 2447 |
//CHECK: %[[RESULT_LB:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2448 |
//CHECK: %[[RBOX_TMP7_1:.*]] = llvm.insertvalue %[[RESULT_LB]], %[[RBOX_TMP6]][7, 0, 0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2449 |
//CHECK: %[[RBOX_TMP7_2:.*]] = llvm.insertvalue %[[RESULT_NELEMS]], %[[RBOX_TMP7_1]][7, 0, 1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2450 |
//CHECK: %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_STRIDE]], %[[RBOX_TMP7_2]][7, 0, 2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2451 |
//CHECK: %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR]], %[[RBOX_TMP7_3]][0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2452 |
//CHECK: llvm.store %[[RESULT_BOX]], %[[RESULT_BOX_REF]] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>, !llvm.ptr |
| 2453 |
//CHECK: llvm.call @bar1(%[[RESULT_BOX_REF]]) : (!llvm.ptr) -> () |
| 2454 |
|
| 2455 |
|
| 2456 |
// Test a rebox of an array section like x(3:60:9)%c(2:8) with both a triplet, a component and a substring where x is a fir.box. |
| 2457 |
func.func private @bar(!fir.box<!fir.array<?x!fir.char<1,?>>>) |
| 2458 |
func.func @foo(%arg0: !fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>) { |
| 2459 |
%c3_i64 = arith.constant 3 : i64 |
| 2460 |
%c60_i64 = arith.constant 60 : i64 |
| 2461 |
%c9_i64 = arith.constant 9 : i64 |
| 2462 |
%c1_i64 = arith.constant 1 : i64 |
| 2463 |
%c7_i64 = arith.constant 7 : i64 |
| 2464 |
%0 = fir.field_index c, !fir.type<t{i:i32,c:!fir.char<1,10>}> |
| 2465 |
%1 = fircg.ext_rebox %arg0[%c3_i64, %c60_i64, %c9_i64] path %0 substr %c1_i64, %c7_i64 : (!fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>, i64, i64, i64, !fir.field, i64, i64) -> !fir.box<!fir.array<?x!fir.char<1,?>>> |
| 2466 |
fir.call @bar(%1) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> () |
| 2467 |
return |
| 2468 |
} |
| 2469 |
|
| 2470 |
//CHECK: llvm.func @bar(!llvm.ptr) attributes {sym_visibility = "private"} |
| 2471 |
//CHECK-LABEL: llvm.func @foo |
| 2472 |
//CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 2473 |
//CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2474 |
//GENERIC: %[[RESULT_BOX_REF:.*]] = llvm.alloca %[[ONE]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr |
| 2475 |
//AMDGPU: %[[AA:.*]] = llvm.alloca %[[ONE]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5> |
| 2476 |
//AMDGPU: %[[RESULT_BOX_REF:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr |
| 2477 |
//CHECK: %[[RESULT_LB:.*]] = llvm.mlir.constant(3 : i64) : i64 |
| 2478 |
//CHECK: %[[RESULT_UB:.*]] = llvm.mlir.constant(60 : i64) : i64 |
| 2479 |
//CHECK: %[[RESULT_STRIDE:.*]] = llvm.mlir.constant(9 : i64) : i64 |
| 2480 |
//CHECK: %[[COMPONENT_OFFSET_1:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2481 |
//CHECK: %[[ELEM_COUNT:.*]] = llvm.mlir.constant(7 : i64) : i64 |
| 2482 |
//CHECK: %[[TYPE_CHAR:.*]] = llvm.mlir.constant(40 : i32) : i32 |
| 2483 |
//CHECK: %[[CHAR_SIZE:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2484 |
//CHECK: %[[ELEM_SIZE:.*]] = llvm.mul %[[CHAR_SIZE]], %[[ELEM_COUNT]] |
| 2485 |
//CHECK: %[[EXTRA_GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)> |
| 2486 |
//CHECK: %[[EXTRA:.*]] = llvm.load %[[EXTRA_GEP]] : !llvm.ptr -> i8 |
| 2487 |
//CHECK: %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE]], %{{.*}}[1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2488 |
//CHECK: %[[RBOX_TMP2:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP1]][2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2489 |
//CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 |
| 2490 |
//CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 |
| 2491 |
//CHECK: %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2492 |
//CHECK: %[[TYPE_CHAR_I8:.*]] = llvm.trunc %[[TYPE_CHAR]] : i32 to i8 |
| 2493 |
//CHECK: %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[TYPE_CHAR_I8]], %[[RBOX_TMP3]][4] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2494 |
//CHECK: %[[RBOX_TMP5:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP4]][5] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2495 |
//CHECK: %[[MASK:.*]] = llvm.mlir.constant(254 : ui8) : i8 |
| 2496 |
//CHECK: %[[EXTRA_WITH_ADDENDUM_CORRECTION:.*]] = llvm.and %[[EXTRA]], %[[MASK]] : i8 |
| 2497 |
//CHECK: %[[RBOX_TMP6:.*]] = llvm.insertvalue %[[EXTRA_WITH_ADDENDUM_CORRECTION]], %[[RBOX_TMP5]][6] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2498 |
//CHECK: %[[SRC_STRIDE_PTR:.*]] = llvm.getelementptr %[[ARG0]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)> |
| 2499 |
//CHECK: %[[SRC_STRIDE:.*]] = llvm.load %[[SRC_STRIDE_PTR]] : !llvm.ptr -> i64 |
| 2500 |
//CHECK: %[[SRC_ARRAY_PTR:.*]] = llvm.getelementptr %[[ARG0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)> |
| 2501 |
//CHECK: %[[SRC_ARRAY:.*]] = llvm.load %[[SRC_ARRAY_PTR]] : !llvm.ptr -> !llvm.ptr |
| 2502 |
//CHECK: %[[ZERO_6:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2503 |
//CHECK: %[[COMPONENT:.*]] = llvm.getelementptr %[[SRC_ARRAY]][%[[ZERO_6]], 1, %[[COMPONENT_OFFSET_1]]] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<"t", (i32, array<10 x i8>)> |
| 2504 |
//CHECK: %[[SRC_LB:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2505 |
//CHECK: %[[RESULT_TMP0:.*]] = llvm.sub %[[RESULT_LB]], %[[SRC_LB]] : i64 |
| 2506 |
//CHECK: %[[RESULT_OFFSET_START:.*]] = llvm.mul %[[RESULT_TMP0]], %[[SRC_STRIDE]] : i64 |
| 2507 |
//CHECK: %[[RESULT_PTR:.*]] = llvm.getelementptr %[[COMPONENT]][%[[RESULT_OFFSET_START]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2508 |
//CHECK: %[[RESULT_TMP1:.*]] = llvm.sub %[[RESULT_UB]], %[[RESULT_LB]] : i64 |
| 2509 |
//CHECK: %[[RESULT_TMP2:.*]] = llvm.add %[[RESULT_TMP1]], %[[RESULT_STRIDE]] : i64 |
| 2510 |
//CHECK: %[[RESULT_TMP3:.*]] = llvm.sdiv %[[RESULT_TMP2]], %[[RESULT_STRIDE]] : i64 |
| 2511 |
//CHECK: %[[RESULT_TMP_PRED:.*]] = llvm.icmp "sgt" %[[RESULT_TMP3]], %[[ZERO_6]] : i64 |
| 2512 |
//CHECK: %[[RESULT_NELEMS:.*]] = llvm.select %[[RESULT_TMP_PRED]], %[[RESULT_TMP3]], %[[ZERO_6]] : i1, i64 |
| 2513 |
//CHECK: %[[RESULT_TOTAL_STRIDE:.*]] = llvm.mul %[[RESULT_STRIDE]], %[[SRC_STRIDE]] : i64 |
| 2514 |
//CHECK: %[[RESULT_LB:.*]] = llvm.mlir.constant(1 : i64) : i64 |
| 2515 |
//CHECK: %[[RBOX_TMP7_1:.*]] = llvm.insertvalue %[[RESULT_LB]], %[[RBOX_TMP6]][7, 0, 0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2516 |
//CHECK: %[[RBOX_TMP7_2:.*]] = llvm.insertvalue %[[RESULT_NELEMS]], %[[RBOX_TMP7_1]][7, 0, 1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2517 |
//CHECK: %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_TOTAL_STRIDE]], %[[RBOX_TMP7_2]][7, 0, 2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2518 |
//CHECK: %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR]], %[[RBOX_TMP7_3]][0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> |
| 2519 |
//CHECK: llvm.store %[[RESULT_BOX]], %[[RESULT_BOX_REF]] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>, !llvm.ptr |
| 2520 |
//CHECK: llvm.call @bar(%[[RESULT_BOX_REF]]) : (!llvm.ptr) -> () |
| 2521 |
//CHECK: llvm.return |
| 2522 |
//CHECK: } |
| 2523 |
|
| 2524 |
// ----- |
| 2525 |
|
| 2526 |
// Test `fir.coordinate_of` conversion (items inside `!fir.box`) |
| 2527 |
|
| 2528 |
// 1. COMPLEX TYPE (`fir.complex` is a special case) |
| 2529 |
// Complex type wrapped in `fir.ref` |
| 2530 |
func.func @coordinate_ref_complex(%arg0: !fir.ref<complex<f128>>) { |
| 2531 |
%arg1 = llvm.mlir.constant(0 : i32) : i32 |
| 2532 |
%p = fir.coordinate_of %arg0, %arg1 : (!fir.ref<complex<f128>>, i32) -> !fir.ref<f32> |
| 2533 |
return |
| 2534 |
} |
| 2535 |
// CHECK-LABEL: llvm.func @coordinate_ref_complex |
| 2536 |
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr |
| 2537 |
// CHECK: %{{.*}} = llvm.getelementptr %[[ARG0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(f128, f128)> |
| 2538 |
// CHECK-NEXT: llvm.return |
| 2539 |
|
| 2540 |
// ----- |
| 2541 |
|
| 2542 |
// Complex type wrapped in `fir.box` |
| 2543 |
func.func @coordinate_box_complex(%arg0: !fir.box<complex<f128>>) { |
| 2544 |
%arg1 = llvm.mlir.constant(0 : i32) : i32 |
| 2545 |
%p = fir.coordinate_of %arg0, %arg1 : (!fir.box<complex<f128>>, i32) -> !fir.ref<f32> |
| 2546 |
return |
| 2547 |
} |
| 2548 |
// CHECK-LABEL: llvm.func @coordinate_box_complex |
| 2549 |
// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr |
| 2550 |
// CHECK: %{{.*}} = llvm.getelementptr %[[BOX]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(f128, f128)> |
| 2551 |
// CHECK-NEXT: llvm.return |
| 2552 |
|
| 2553 |
// ----- |
| 2554 |
|
| 2555 |
// Test `fir.coordinate_of` conversion (items inside `!fir.box`) |
| 2556 |
|
| 2557 |
// 2. BOX TYPE (objects wrapped in `fir.box`) |
| 2558 |
// Derived type - basic case (1 index) |
| 2559 |
func.func @coordinate_box_derived_1(%arg0: !fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>) { |
| 2560 |
%q = fir.coordinate_of %arg0, field_2 : (!fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>) -> !fir.ref<i32> |
| 2561 |
return |
| 2562 |
} |
| 2563 |
// CHECK-LABEL: llvm.func @coordinate_box_derived_1 |
| 2564 |
// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr) |
| 2565 |
// CHECK: %[[DERIVED_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i64>)> |
| 2566 |
// CHECK: %[[DERIVED_VAL:.*]] = llvm.load %[[DERIVED_ADDR]] : !llvm.ptr -> !llvm.ptr |
| 2567 |
// CHECK: %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[DERIVED_VAL]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"derived_1", (i32, i32)> |
| 2568 |
// CHECK-NEXT: llvm.return |
| 2569 |
|
| 2570 |
// Derived type - basic case (2 indices) |
| 2571 |
func.func @coordinate_box_derived_2(%arg0: !fir.box<!fir.type<derived_2{field_1:!fir.type<another_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) { |
| 2572 |
%q = fir.coordinate_of %arg0, field_1, inner2 : (!fir.box<!fir.type<derived_2{field_1:!fir.type<another_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) -> !fir.ref<i32> |
| 2573 |
return |
| 2574 |
} |
| 2575 |
|
| 2576 |
// CHECK-LABEL: llvm.func @coordinate_box_derived_2 |
| 2577 |
// CHECK-SAME: (%[[BOX:.*]]: !llvm.ptr) |
| 2578 |
// CHECK: %[[DERIVED_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}32, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i64>)> |
| 2579 |
// CHECK-NEXT: %[[DERIVED_VAL:.*]] = llvm.load %[[DERIVED_ADDR]] : !llvm.ptr -> !llvm.ptr |
| 2580 |
// CHECK-NEXT: %[[ANOTHER_DERIVED_ADDR:.*]] = llvm.getelementptr %[[DERIVED_VAL]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"derived_2", (struct<"another_derived", (i32, f32)>, i32)> |
| 2581 |
// CHECK-NEXT: %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ANOTHER_DERIVED_ADDR]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"another_derived", (i32, f32)> |
| 2582 |
// CHECK-NEXT: llvm.return |
| 2583 |
|
| 2584 |
// TODO: Derived type - special case with `fir.len_param_index` |
| 2585 |
|
| 2586 |
// ----- |
| 2587 |
|
| 2588 |
// Test `fir.coordinate_of` conversion (items inside `!fir.box`) |
| 2589 |
|
| 2590 |
// 3. BOX TYPE - `fir.array` wrapped in `fir.box` |
| 2591 |
// `fir.array` inside a `fir.box` (1d) |
| 2592 |
func.func @coordinate_box_array_1d(%arg0: !fir.box<!fir.array<10 x f32>>, %arg1: index) { |
| 2593 |
%p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.array<10 x f32>>, index) -> !fir.ref<f32> |
| 2594 |
return |
| 2595 |
} |
| 2596 |
// CHECK-LABEL: llvm.func @coordinate_box_array_1d |
| 2597 |
// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr |
| 2598 |
// CHECK-SAME: %[[COORDINATE:.*]]: i64 |
| 2599 |
// There's only one box here. Its index is `0`. Generate it. |
| 2600 |
// CHECK: %[[ARRAY_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2601 |
// CHECK-NEXT: %[[ARRAY_OBJECT:.*]] = llvm.load %[[ARRAY_ADDR]] : !llvm.ptr -> !llvm.ptr |
| 2602 |
// CHECK-NEXT: %[[OFFSET_INIT:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2603 |
// Index of the 1st CFI_dim_t object (corresonds the the 1st dimension) |
| 2604 |
// CHECK-NEXT: %[[DIM_1_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2605 |
// CHECK-NEXT: %[[DIM_1_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_1_MEM_STRIDE_ADDR]] : !llvm.ptr -> i64 |
| 2606 |
// CHECK-NEXT: %[[BYTE_OFFSET:.*]] = llvm.mul %[[COORDINATE]], %[[DIM_1_MEM_STRIDE_VAL]] overflow<nsw> : i64 |
| 2607 |
// CHECK-NEXT: %[[SUBOJECT_OFFSET:.*]] = llvm.add %[[BYTE_OFFSET]], %[[OFFSET_INIT]] overflow<nsw> : i64 |
| 2608 |
// CHECK-NEXT: %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_OBJECT]][%[[SUBOJECT_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2609 |
// CHECK-NEXT: llvm.return |
| 2610 |
|
| 2611 |
// `fir.array` inside a `fir.box` (1d) - dynamic size |
| 2612 |
func.func @coordinate_of_box_dynamic_array_1d(%arg0: !fir.box<!fir.array<? x f32>>, %arg1: index) { |
| 2613 |
%p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.array<? x f32>>, index) -> !fir.ref<f32> |
| 2614 |
return |
| 2615 |
} |
| 2616 |
// CHECK-LABEL: llvm.func @coordinate_of_box_dynamic_array_1d |
| 2617 |
// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr |
| 2618 |
// CHECK-SAME: %[[COORDINATE:.*]]: i64 |
| 2619 |
// CHECK-NEXT: %[[ARRAY_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2620 |
// CHECK-NEXT: %[[ARRAY_OBJECT:.*]] = llvm.load %[[ARRAY_ADDR]] : !llvm.ptr -> !llvm.ptr |
| 2621 |
// CHECK-NEXT: %[[OFFSET_INIT:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2622 |
// Index of the 1st CFI_dim_t object (corresonds the the 1st dimension) |
| 2623 |
// CHECK-NEXT: %[[DIM_1_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> |
| 2624 |
// CHECK-NEXT: %[[DIM_1_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_1_MEM_STRIDE_ADDR]] : !llvm.ptr -> i64 |
| 2625 |
// CHECK-NEXT: %[[BYTE_OFFSET:.*]] = llvm.mul %[[COORDINATE]], %[[DIM_1_MEM_STRIDE_VAL]] overflow<nsw> : i64 |
| 2626 |
// CHECK-NEXT: %[[SUBOJECT_OFFSET:.*]] = llvm.add %[[BYTE_OFFSET]], %[[OFFSET_INIT]] overflow<nsw> : i64 |
| 2627 |
// CHECK-NEXT: %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_OBJECT]][%[[SUBOJECT_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2628 |
// CHECK-NEXT: llvm.return |
| 2629 |
|
| 2630 |
// ----- |
| 2631 |
|
| 2632 |
// `fir.array` inside a `fir.box` (2d) |
| 2633 |
func.func @coordinate_box_array_2d(%arg0: !fir.box<!fir.array<10 x 10 x f32>>, %arg1: index, %arg2: index) { |
| 2634 |
%p = fir.coordinate_of %arg0, %arg1, %arg2 : (!fir.box<!fir.array<10 x 10 x f32>>, index, index) -> !fir.ref<f32> |
| 2635 |
return |
| 2636 |
} |
| 2637 |
// CHECK-LABEL: llvm.func @coordinate_box_array_2d |
| 2638 |
// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr |
| 2639 |
// CHECK-SAME: %[[COORDINATE_1:.*]]: i64, %[[COORDINATE_2:.*]]: i64) |
| 2640 |
// CHECK-NEXT: %[[ARRAY_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2641 |
// CHECK-NEXT: %[[ARRAY_OBJECT:.*]] = llvm.load %[[ARRAY_ADDR]] : !llvm.ptr -> !llvm.ptr |
| 2642 |
// CHECK-NEXT: %[[OFFSET_INIT:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2643 |
// Index of the 1st CFI_dim_t object (corresonds the the 1st dimension) |
| 2644 |
// CHECK-NEXT: %[[DIM_1_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2645 |
// CHECK-NEXT: %[[DIM_1_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_1_MEM_STRIDE_ADDR]] : !llvm.ptr -> i64 |
| 2646 |
// CHECK-NEXT: %[[BYTE_OFFSET_1:.*]] = llvm.mul %[[COORDINATE_1]], %[[DIM_1_MEM_STRIDE_VAL]] overflow<nsw> : i64 |
| 2647 |
// CHECK-NEXT: %[[SUBOBJECT_OFFSET_1:.*]] = llvm.add %[[BYTE_OFFSET]], %[[OFFSET_INIT]] overflow<nsw> : i64 |
| 2648 |
// Index of the 1st CFI_dim_t object (corresonds the the 2nd dimension) |
| 2649 |
// CHECK-NEXT: %[[DIM_2_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][0, 7, 1, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> |
| 2650 |
// CHECK-NEXT: %[[DIM_2_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_2_MEM_STRIDE_ADDR]] : !llvm.ptr -> i64 |
| 2651 |
// CHECK-NEXT: %[[BYTE_OFFSET_2:.*]] = llvm.mul %[[COORDINATE_2]], %[[DIM_2_MEM_STRIDE_VAL]] overflow<nsw> : i64 |
| 2652 |
// CHECK-NEXT: %[[SUBOBJECT_OFFSET_2:.*]] = llvm.add %[[BYTE_OFFSET_2]], %[[SUBOBJECT_OFFSET_1]] overflow<nsw> : i64 |
| 2653 |
// CHECK-NEXT: %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_OBJECT]][%[[SUBOBJECT_OFFSET_2]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2654 |
// CHECK-NEXT: llvm.return |
| 2655 |
|
| 2656 |
// ----- |
| 2657 |
|
| 2658 |
// Test `fir.coordinate_of` conversion (items inside `!fir.box`) |
| 2659 |
|
| 2660 |
// 4. BOX TYPE - `fir.derived` inside `fir.array` |
| 2661 |
func.func @coordinate_box_derived_inside_array(%arg0: !fir.box<!fir.array<10 x !fir.type<derived_3{field_1:f32, field_2:f32}>>>, %arg1 : index) { |
| 2662 |
%q = fir.coordinate_of %arg0, %arg1, field_2 : (!fir.box<!fir.array<10 x !fir.type<derived_3{field_1:f32, field_2:f32}>>>, index) -> !fir.ref<f32> |
| 2663 |
return |
| 2664 |
} |
| 2665 |
// CHECK-LABEL: llvm.func @coordinate_box_derived_inside_array( |
| 2666 |
// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr, |
| 2667 |
// CHECK-SAME: %[[COORDINATE_1:.*]]: i64) { |
| 2668 |
// CHECK: %[[VAL_6:.*]] = llvm.getelementptr %[[BOX]]{{\[}}0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)> |
| 2669 |
// CHECK: %[[ARRAY:.*]] = llvm.load %[[VAL_6]] : !llvm.ptr -> !llvm.ptr |
| 2670 |
// CHECK: %[[VAL_8:.*]] = llvm.mlir.constant(0 : i64) : i64 |
| 2671 |
// CHECK: %[[VAL_13:.*]] = llvm.getelementptr %[[BOX]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)> |
| 2672 |
// CHECK: %[[VAL_14:.*]] = llvm.load %[[VAL_13]] : !llvm.ptr -> i64 |
| 2673 |
// CHECK: %[[VAL_15:.*]] = llvm.mul %[[COORDINATE_1]], %[[VAL_14]] overflow<nsw> : i64 |
| 2674 |
// CHECK: %[[OFFSET:.*]] = llvm.add %[[VAL_15]], %[[VAL_8]] overflow<nsw> : i64 |
| 2675 |
// CHECK: %[[DERIVED:.*]] = llvm.getelementptr %[[ARRAY]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 |
| 2676 |
// CHECK: %[[VAL_20:.*]] = llvm.getelementptr %[[DERIVED]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"derived_3", (f32, f32)> |
| 2677 |
// CHECK: llvm.return |
| 2678 |
|
| 2679 |
// ----- |
| 2680 |
|
| 2681 |
// Test `fir.coordinate_of` conversion (items inside `!fir.ref`) |
| 2682 |
|
| 2683 |
// 5.1. `fir.array` |
| 2684 |
func.func @coordinate_array_unknown_size_1d(%arg0: !fir.ref<!fir.array<? x i32>>, %arg1 : index) { |
| 2685 |
%q = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<? x i32>>, index) -> !fir.ref<i32> |
| 2686 |
return |
| 2687 |
} |
| 2688 |
// CHECK-LABEL: llvm.func @coordinate_array_unknown_size_1d( |
| 2689 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, |
| 2690 |
// CHECK-SAME: %[[VAL_1:.*]]: i64) { |
| 2691 |
// CHECK: %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2692 |
// CHECK: llvm.return |
| 2693 |
// CHECK: } |
| 2694 |
|
| 2695 |
// ----- |
| 2696 |
|
| 2697 |
func.func @coordinate_array_known_size_1d(%arg0: !fir.ref<!fir.array<10 x i32>>, %arg1 : index) { |
| 2698 |
%q = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<10 x i32>>, index) -> !fir.ref<i32> |
| 2699 |
return |
| 2700 |
} |
| 2701 |
// CHECK-LABEL: llvm.func @coordinate_array_known_size_1d( |
| 2702 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, |
| 2703 |
// CHECK-SAME: %[[VAL_1:.*]]: i64) { |
| 2704 |
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}0, %[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<10 x i32> |
| 2705 |
// CHECK: llvm.return |
| 2706 |
// CHECK: } |
| 2707 |
|
| 2708 |
// ----- |
| 2709 |
|
| 2710 |
func.func @coordinate_array_known_size_2d_get_i32(%arg0: !fir.ref<!fir.array<10 x 10 x i32>>, %arg1 : index, %arg2 : index) { |
| 2711 |
%q = fir.coordinate_of %arg0, %arg1, %arg2 : (!fir.ref<!fir.array<10 x 10 x i32>>, index, index) -> !fir.ref<i32> |
| 2712 |
return |
| 2713 |
} |
| 2714 |
// CHECK-LABEL: llvm.func @coordinate_array_known_size_2d_get_i32( |
| 2715 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, |
| 2716 |
// CHECK-SAME: %[[VAL_1:.*]]: i64, |
| 2717 |
// CHECK-SAME: %[[VAL_2:.*]]: i64) { |
| 2718 |
// CHECK: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}0, %[[VAL_2]], %[[VAL_1]]] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.array<10 x array<10 x i32> |
| 2719 |
// CHECK: llvm.return |
| 2720 |
// CHECK: } |
| 2721 |
|
| 2722 |
// ----- |
| 2723 |
|
| 2724 |
func.func @coordinate_array_known_size_2d_get_array(%arg0: !fir.ref<!fir.array<10 x 10 x i32>>, %arg1 : index) { |
| 2725 |
%q = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<10 x 10 x i32>>, index) -> !fir.ref<!fir.array<10 x i32>> |
| 2726 |
return |
| 2727 |
} |
| 2728 |
// CHECK-LABEL: llvm.func @coordinate_array_known_size_2d_get_array( |
| 2729 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, |
| 2730 |
// CHECK-SAME: %[[VAL_1:.*]]: i64) { |
| 2731 |
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]][0, %[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<10 x array<10 x i32>> |
| 2732 |
// CHECK: llvm.return |
| 2733 |
// CHECK: } |
| 2734 |
|
| 2735 |
// ----- |
| 2736 |
|
| 2737 |
// 5.2. `fir.derived` |
| 2738 |
func.func @coordinate_ref_derived(%arg0: !fir.ref<!fir.type<dervied_4{field_1:i32, field_2:i32}>>) { |
| 2739 |
%q = fir.coordinate_of %arg0, field_2 : (!fir.ref<!fir.type<dervied_4{field_1:i32, field_2:i32}>>) -> !fir.ref<i32> |
| 2740 |
return |
| 2741 |
} |
| 2742 |
// CHECK-LABEL: llvm.func @coordinate_ref_derived( |
| 2743 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) { |
| 2744 |
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"dervied_4", (i32, i32)> |
| 2745 |
// CHECK: llvm.return |
| 2746 |
// CHECK: } |
| 2747 |
|
| 2748 |
// ----- |
| 2749 |
|
| 2750 |
func.func @coordinate_ref_derived_nested(%arg0: !fir.ref<!fir.type<derived_5{field_1:!fir.type<nested_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) { |
| 2751 |
%q = fir.coordinate_of %arg0, field_1, inner2 : (!fir.ref<!fir.type<derived_5{field_1:!fir.type<nested_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) -> !fir.ref<i32> |
| 2752 |
return |
| 2753 |
} |
| 2754 |
// CHECK-LABEL: llvm.func @coordinate_ref_derived_nested( |
| 2755 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) { |
| 2756 |
// CHECK: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}0, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"derived_5", (struct<"nested_derived", (i32, f32)>, i32)> |
| 2757 |
// CHECK: llvm.return |
| 2758 |
// CHECK: } |
| 2759 |
|
| 2760 |
// ----- |
| 2761 |
|
| 2762 |
// 5.3 `fir.char` |
| 2763 |
func.func @test_coordinate_of_char(%arr : !fir.ref<!fir.char<2, 10>>) { |
| 2764 |
%1 = arith.constant 10 : i32 |
| 2765 |
%2 = fir.coordinate_of %arr, %1 : (!fir.ref<!fir.char<2, 10>>, i32) -> !fir.ref<!fir.char<2>> |
| 2766 |
return |
| 2767 |
} |
| 2768 |
// CHECK-LABEL: llvm.func @test_coordinate_of_char( |
| 2769 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) { |
| 2770 |
// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(10 : i32) : i32 |
| 2771 |
// CHECK: %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}0, %[[VAL_1]]] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.array<10 x i16> |
| 2772 |
// CHECK: llvm.return |
| 2773 |
// CHECK: } |
| 2774 |
|
| 2775 |
// ----- |
| 2776 |
|
| 2777 |
// 5.4 `mlir.tuple` |
| 2778 |
func.func @test_coordinate_of_tuple(%tup : !fir.ref<tuple<!fir.ref<i32>>>) { |
| 2779 |
%1 = arith.constant 0 : i32 |
| 2780 |
%2 = fir.coordinate_of %tup, %1 : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.ref<i32> |
| 2781 |
return |
| 2782 |
} |
| 2783 |
// CHECK-LABEL: llvm.func @test_coordinate_of_tuple( |
| 2784 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) { |
| 2785 |
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr)> |
| 2786 |
// CHECK: llvm.return |
| 2787 |
// CHECK: } |
| 2788 |
|
| 2789 |
// ----- |
| 2790 |
|
| 2791 |
// Test `fir.coordinate_of` conversion - items inside `!fir.ptr`. This should |
| 2792 |
// be almost identical to `!fir.ref` (i.e. it's the same code path in the code |
| 2793 |
// gen). Instead of duplicating the tests, only one for sanity-checking is added. |
| 2794 |
|
| 2795 |
// 6.1. `fir.array` |
| 2796 |
func.func @coordinate_array_unknown_size_1d(%arg0: !fir.ptr<!fir.array<? x i32>>, %arg1 : index) { |
| 2797 |
%q = fir.coordinate_of %arg0, %arg1 : (!fir.ptr<!fir.array<? x i32>>, index) -> !fir.ref<i32> |
| 2798 |
return |
| 2799 |
} |
| 2800 |
// CHECK-LABEL: llvm.func @coordinate_array_unknown_size_1d( |
| 2801 |
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, |
| 2802 |
// CHECK-SAME: %[[VAL_1:.*]]: i64) { |
| 2803 |
// CHECK: %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_1]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 |
| 2804 |
// CHECK: llvm.return |
| 2805 |
// CHECK: } |
| 2806 |
|
| 2807 |
// ----- |
| 2808 |
|
| 2809 |
fir.global common @c_(dense<0> : vector<4294967296xi8>) : !fir.array<4294967296xi8> |
| 2810 |
|
| 2811 |
// CHECK: llvm.mlir.global common @c_(dense<0> : vector<4294967296xi8>) {addr_space = 0 : i32} : !llvm.array<4294967296 x i8> |
| 2812 |
|
| 2813 |
// ----- |
| 2814 |
|
| 2815 |
gpu.module @cuda_device_mod { |
| 2816 |
gpu.func @test_alloc_and_freemem_one() { |
| 2817 |
%z0 = fir.allocmem i32 |
| 2818 |
fir.freemem %z0 : !fir.heap<i32> |
| 2819 |
gpu.return |
| 2820 |
} |
| 2821 |
} |
| 2822 |
|
| 2823 |
// CHECK: gpu.module @cuda_device_mod { |
| 2824 |
// CHECK: llvm.func @free(!llvm.ptr) |
| 2825 |
// CHECK: llvm.func @malloc(i64) -> !llvm.ptr |
| 2826 |
// CHECK: llvm.call @malloc |
| 2827 |
// CHECK: lvm.call @free |
| 2828 |
|
| 2829 |
// ----- |
| 2830 |
|
| 2831 |
func.func private @somefunc(i32, !fir.ref<i64>) |
| 2832 |
|
| 2833 |
// CHECK-LABEL: @test_call_arg_attrs_direct |
| 2834 |
func.func @test_call_arg_attrs_direct(%arg0: i32, %arg1: !fir.ref<i64>) { |
| 2835 |
// CHECK: llvm.call @somefunc(%{{.*}}, %{{.*}}) : (i32, !llvm.ptr {llvm.byval = i64}) -> () |
| 2836 |
fir.call @somefunc(%arg0, %arg1) : (i32, !fir.ref<i64> {llvm.byval = i64}) -> () |
| 2837 |
return |
| 2838 |
} |
| 2839 |
|
| 2840 |
// CHECK-LABEL: @test_call_arg_attrs_indirect |
| 2841 |
func.func @test_call_arg_attrs_indirect(%arg0: i16, %arg1: (i16)-> i16) -> i16 { |
| 2842 |
// CHECK: llvm.call %arg1(%{{.*}}) : !llvm.ptr, (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext}) |
| 2843 |
%0 = fir.call %arg1(%arg0) : (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext}) |
| 2844 |
return %0 : i16 |
| 2845 |
} |
| 2846 |
|
| 2847 |
// CHECK-LABEL: @test_byval |
| 2848 |
func.func @test_byval(%arg0: (!fir.ref<!fir.type<t{a:!fir.array<5xf64>}>>, f64) -> (), %arg1: !fir.ref<!fir.type<t{a:!fir.array<5xf64>}>>, %arg2: f64) { |
| 2849 |
// llvm.call %{{.*}}(%{{.*}}, %{{.*}}) : !llvm.ptr, (!llvm.ptr {llvm.byval = !llvm.struct<"t", (array<5 x f64>)>}, f64) -> () |
| 2850 |
fir.call %arg0(%arg1, %arg2) : (!fir.ref<!fir.type<t{a:!fir.array<5xf64>}>> {llvm.byval = !fir.type<t{a:!fir.array<5xf64>}>}, f64) -> () |
| 2851 |
return |
| 2852 |
} |
| 2853 |
|
| 2854 |
// CHECK-LABEL: @test_sret |
| 2855 |
func.func @test_sret(%arg0: (!fir.ref<!fir.type<t{a:!fir.array<5xf64>}>>, f64) -> (), %arg1: !fir.ref<!fir.type<t{a:!fir.array<5xf64>}>>, %arg2: f64) { |
| 2856 |
// llvm.call %{{.*}}(%{{.*}}, %{{.*}}) : !llvm.ptr, (!llvm.ptr {llvm.sret = !llvm.struct<"t", (array<5 x f64>)>}, f64) -> () |
| 2857 |
fir.call %arg0(%arg1, %arg2) : (!fir.ref<!fir.type<t{a:!fir.array<5xf64>}>> {llvm.sret = !fir.type<t{a:!fir.array<5xf64>}>}, f64) -> () |
| 2858 |
return |
| 2859 |
} |