Debian Codegraph @

flang/test/Fir/convert-to-llvm.fir

raw
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 }