Debian Codegraph @

flang/test/Fir/alloc.fir

raw
1 // RUN: tco %s | FileCheck %s
2 // RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
3
4 // UNSUPPORTED: system-windows
5 // Disabled on 32-bit targets due to the additional `trunc` opcodes required
6 // UNSUPPORTED: target-x86
7 // UNSUPPORTED: target=sparc-{{.*}}
8 // UNSUPPORTED: target=sparcel-{{.*}}
9
10 // CHECK-LABEL: define ptr @alloca_scalar_nonchar()
11 // CHECK: alloca i32, i64 1
12 func.func @alloca_scalar_nonchar() -> !fir.ref<i32> {
13 %1 = fir.alloca i32
14 return %1 : !fir.ref<i32>
15 }
16
17 // CHECK-LABEL: define ptr @alloca_scalars_nonchar()
18 // CHECK: alloca i32, i64 100
19 func.func @alloca_scalars_nonchar() -> !fir.ref<i32> {
20 %0 = arith.constant 100 : index
21 %1 = fir.alloca i32, %0
22 return %1 : !fir.ref<i32>
23 }
24
25 // CHECK-LABEL: define ptr @allocmem_scalar_nonchar(
26 // CHECK: call ptr @malloc(i64 4)
27 func.func @allocmem_scalar_nonchar() -> !fir.heap<i32> {
28 %1 = fir.allocmem i32
29 return %1 : !fir.heap<i32>
30 }
31
32 // CHECK-LABEL: define ptr @allocmem_scalars_nonchar(
33 // CHECK: call ptr @malloc(i64 400)
34 func.func @allocmem_scalars_nonchar() -> !fir.heap<i32> {
35 %0 = arith.constant 100 : index
36 %1 = fir.allocmem i32, %0
37 return %1 : !fir.heap<i32>
38 }
39
40 // CHECK-LABEL: define ptr @alloca_scalar_char(
41 // CHECK: alloca [10 x i8], i64 1
42 func.func @alloca_scalar_char() -> !fir.ref<!fir.char<1,10>> {
43 %1 = fir.alloca !fir.char<1,10>
44 return %1 : !fir.ref<!fir.char<1,10>>
45 }
46
47 // CHECK-LABEL: define ptr @alloca_scalar_char_kind(
48 // CHECK: alloca [10 x i16], i64 1
49 func.func @alloca_scalar_char_kind() -> !fir.ref<!fir.char<2,10>> {
50 %1 = fir.alloca !fir.char<2,10>
51 return %1 : !fir.ref<!fir.char<2,10>>
52 }
53
54 // CHECK-LABEL: define ptr @allocmem_scalar_char(
55 // CHECK: call ptr @malloc(i64 10)
56 func.func @allocmem_scalar_char() -> !fir.heap<!fir.char<1,10>> {
57 %1 = fir.allocmem !fir.char<1,10>
58 return %1 : !fir.heap<!fir.char<1,10>>
59 }
60
61 // CHECK-LABEL: define ptr @allocmem_scalar_char_kind(
62 // CHECK: call ptr @malloc(i64 20)
63 func.func @allocmem_scalar_char_kind() -> !fir.heap<!fir.char<2,10>> {
64 %1 = fir.allocmem !fir.char<2,10>
65 return %1 : !fir.heap<!fir.char<2,10>>
66 }
67
68 // CHECK-LABEL: define ptr @alloca_scalar_dynchar(
69 // CHECK-SAME: i32 %[[len:.*]])
70 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
71 // CHECK: alloca i8, i64 %[[mul1]]
72 func.func @alloca_scalar_dynchar(%l : i32) -> !fir.ref<!fir.char<1,?>> {
73 %1 = fir.alloca !fir.char<1,?>(%l : i32)
74 return %1 : !fir.ref<!fir.char<1,?>>
75 }
76
77 // CHECK-LABEL: define ptr @alloca_scalar_dynchar_kind(
78 // CHECK-SAME: i32 %[[len:.*]])
79 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
80 // CHECK: alloca i16, i64 %[[mul1]]
81 func.func @alloca_scalar_dynchar_kind(%l : i32) -> !fir.ref<!fir.char<2,?>> {
82 %1 = fir.alloca !fir.char<2,?>(%l : i32)
83 return %1 : !fir.ref<!fir.char<2,?>>
84 }
85
86 // CHECK-LABEL: define ptr @allocmem_scalar_dynchar(
87 // CHECK-SAME: i32 %[[len:.*]])
88 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
89 // CHECK: %[[mul2:.*]] = mul i64 1, %[[mul1]]
90 // CHECK: call ptr @malloc(i64 %[[mul2]])
91 func.func @allocmem_scalar_dynchar(%l : i32) -> !fir.heap<!fir.char<1,?>> {
92 %1 = fir.allocmem !fir.char<1,?>(%l : i32)
93 return %1 : !fir.heap<!fir.char<1,?>>
94 }
95
96 // CHECK-LABEL: define ptr @allocmem_scalar_dynchar_kind(
97 // CHECK-SAME: i32 %[[len:.*]])
98 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
99 // CHECK: %[[mul2:.*]] = mul i64 2, %[[mul1]]
100 // CHECK: call ptr @malloc(i64 %[[mul2]])
101 func.func @allocmem_scalar_dynchar_kind(%l : i32) -> !fir.heap<!fir.char<2,?>>{
102 %1 = fir.allocmem !fir.char<2,?>(%l : i32)
103 return %1 : !fir.heap<!fir.char<2,?>>
104 }
105
106 // CHECK-LABEL: define ptr @alloca_ptr_to_dynarray_nonchar(
107 // CHECK: %1 = alloca ptr, i64 1
108 func.func @alloca_ptr_to_dynarray_nonchar() -> !fir.ref<!fir.ptr<!fir.array<?xi32>>> {
109 %1 = fir.alloca !fir.ptr<!fir.array<?xi32>>
110 return %1 : !fir.ref<!fir.ptr<!fir.array<?xi32>>>
111 }
112
113 // CHECK-LABEL: define ptr @alloca_array_of_nonchar(
114 // CHECK: alloca [3 x [3 x i32]], i64 1
115 func.func @alloca_array_of_nonchar() -> !fir.ref<!fir.array<3x3xi32>> {
116 %1 = fir.alloca !fir.array<3x3xi32>
117 return %1 : !fir.ref<!fir.array<3x3xi32>>
118 }
119
120 // CHECK-LABEL: define ptr @alloca_array_of_char(
121 // CHECK: alloca [3 x [3 x [10 x i8]]], i64 1
122 func.func @alloca_array_of_char() -> !fir.ref<!fir.array<3x3x!fir.char<1,10>>> {
123 %1 = fir.alloca !fir.array<3x3x!fir.char<1,10>>
124 return %1 : !fir.ref<!fir.array<3x3x!fir.char<1,10>>>
125 }
126
127 // CHECK-LABEL: define ptr @alloca_array_of_dynchar(
128 // CHECK-SAME: i32 %[[len:.*]])
129 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
130 // CHECK: %[[mul2:.*]] = mul i64 %[[mul1]], 9
131 // CHECK: alloca i8, i64 %[[mul2]]
132 func.func @alloca_array_of_dynchar(%l: i32) -> !fir.ref<!fir.array<3x3x!fir.char<1,?>>> {
133 %1 = fir.alloca !fir.array<3x3x!fir.char<1,?>>(%l : i32)
134 return %1 : !fir.ref<!fir.array<3x3x!fir.char<1,?>>>
135 }
136
137 // CHECK-LABEL: define ptr @allocmem_array_of_nonchar(
138 // CHECK: call ptr @malloc(i64 36)
139 func.func @allocmem_array_of_nonchar() -> !fir.heap<!fir.array<3x3xi32>> {
140 %1 = fir.allocmem !fir.array<3x3xi32>
141 return %1 : !fir.heap<!fir.array<3x3xi32>>
142 }
143
144 // CHECK-LABEL: define ptr @allocmem_array_of_char(
145 // CHECK: call ptr @malloc(i64 90)
146 func.func @allocmem_array_of_char() -> !fir.heap<!fir.array<3x3x!fir.char<1,10>>> {
147 %1 = fir.allocmem !fir.array<3x3x!fir.char<1,10>>
148 return %1 : !fir.heap<!fir.array<3x3x!fir.char<1,10>>>
149 }
150
151 // CHECK-LABEL: define ptr @allocmem_array_of_dynchar(
152 // CHECK-SAME: i32 %[[len:.*]])
153 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
154 // CHECK: %[[mul2:.*]] = mul i64 9, %[[mul1]]
155 // CHECK: call ptr @malloc(i64 %[[mul2]])
156 func.func @allocmem_array_of_dynchar(%l: i32) -> !fir.heap<!fir.array<3x3x!fir.char<1,?>>> {
157 %1 = fir.allocmem !fir.array<3x3x!fir.char<1,?>>(%l : i32)
158 return %1 : !fir.heap<!fir.array<3x3x!fir.char<1,?>>>
159 }
160
161 // CHECK-LABEL: define ptr @alloca_dynarray_of_nonchar(
162 // CHECK-SAME: i64 %[[extent:.*]])
163 // CHECK: %[[prod1:.*]] = mul i64 %[[extent]], 1
164 // CHECK: alloca [3 x i32], i64 %[[prod1]]
165 func.func @alloca_dynarray_of_nonchar(%e: index) -> !fir.ref<!fir.array<3x?xi32>> {
166 %1 = fir.alloca !fir.array<3x?xi32>, %e
167 return %1 : !fir.ref<!fir.array<3x?xi32>>
168 }
169
170 // CHECK-LABEL: define ptr @alloca_dynarray_of_nonchar2(
171 // CHECK-SAME: i64 %[[extent:.*]])
172 // CHECK: %[[prod1:.*]] = mul i64 %[[extent]], 1
173 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
174 // CHECK: alloca i32, i64 %[[prod2]]
175 func.func @alloca_dynarray_of_nonchar2(%e: index) -> !fir.ref<!fir.array<?x?xi32>> {
176 %1 = fir.alloca !fir.array<?x?xi32>, %e, %e
177 return %1 : !fir.ref<!fir.array<?x?xi32>>
178 }
179
180 // CHECK-LABEL: define ptr @allocmem_dynarray_of_nonchar(
181 // CHECK-SAME: i64 %[[extent:.*]])
182 // CHECK: %[[prod1:.*]] = mul i64 12, %[[extent]]
183 // CHECK: call ptr @malloc(i64 %[[prod1]])
184 func.func @allocmem_dynarray_of_nonchar(%e: index) -> !fir.heap<!fir.array<3x?xi32>> {
185 %1 = fir.allocmem !fir.array<3x?xi32>, %e
186 return %1 : !fir.heap<!fir.array<3x?xi32>>
187 }
188
189 // CHECK-LABEL: define ptr @allocmem_dynarray_of_nonchar2(
190 // CHECK-SAME: i64 %[[extent:.*]])
191 // CHECK: %[[prod1:.*]] = mul i64 4, %[[extent]]
192 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
193 // CHECK: call ptr @malloc(i64 %[[prod2]])
194 func.func @allocmem_dynarray_of_nonchar2(%e: index) -> !fir.heap<!fir.array<?x?xi32>> {
195 %1 = fir.allocmem !fir.array<?x?xi32>, %e, %e
196 return %1 : !fir.heap<!fir.array<?x?xi32>>
197 }
198
199 // CHECK-LABEL: define ptr @alloca_dynarray_of_char(
200 // CHECK-SAME: i64 %[[extent:.*]])
201 // CHECK: %[[prod1:.*]] = mul i64 %[[extent]], 1
202 // CHECK: alloca [3 x [10 x i16]], i64 %[[prod1]]
203 func.func @alloca_dynarray_of_char(%e : index) -> !fir.ref<!fir.array<3x?x!fir.char<2,10>>> {
204 %1 = fir.alloca !fir.array<3x?x!fir.char<2,10>>, %e
205 return %1 : !fir.ref<!fir.array<3x?x!fir.char<2,10>>>
206 }
207
208 // CHECK-LABEL: define ptr @alloca_dynarray_of_char2(
209 // CHECK-SAME: i64 %[[extent:.*]])
210 // CHECK: %[[prod1:.*]] = mul i64 %[[extent]], 1
211 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
212 // CHECK: alloca [10 x i16], i64 %[[prod2]]
213 func.func @alloca_dynarray_of_char2(%e : index) -> !fir.ref<!fir.array<?x?x!fir.char<2,10>>> {
214 %1 = fir.alloca !fir.array<?x?x!fir.char<2,10>>, %e, %e
215 return %1 : !fir.ref<!fir.array<?x?x!fir.char<2,10>>>
216 }
217
218 // CHECK-LABEL: define ptr @allocmem_dynarray_of_char(
219 // CHECK-SAME: i64 %[[extent:.*]])
220 // CHECK: %[[prod1:.*]] = mul i64 60, %[[extent]]
221 // CHECK: call ptr @malloc(i64 %[[prod1]])
222 func.func @allocmem_dynarray_of_char(%e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,10>>> {
223 %1 = fir.allocmem !fir.array<3x?x!fir.char<2,10>>, %e
224 return %1 : !fir.heap<!fir.array<3x?x!fir.char<2,10>>>
225 }
226
227 // CHECK-LABEL: define ptr @allocmem_dynarray_of_char2(
228 // CHECK-SAME: i64 %[[extent:.*]])
229 // CHECK: %[[prod1:.*]] = mul i64 20, %[[extent]]
230 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
231 // CHECK: call ptr @malloc(i64 %[[prod2]])
232 func.func @allocmem_dynarray_of_char2(%e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,10>>> {
233 %1 = fir.allocmem !fir.array<?x?x!fir.char<2,10>>, %e, %e
234 return %1 : !fir.heap<!fir.array<?x?x!fir.char<2,10>>>
235 }
236
237 // CHECK-LABEL: define ptr @alloca_dynarray_of_dynchar(
238 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
239 // CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
240 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], 3
241 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
242 // CHECK: alloca i16, i64 %[[prod3]]
243 func.func @alloca_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.ref<!fir.array<3x?x!fir.char<2,?>>> {
244 %1 = fir.alloca !fir.array<3x?x!fir.char<2,?>>(%l : i32), %e
245 return %1 : !fir.ref<!fir.array<3x?x!fir.char<2,?>>>
246 }
247
248 // CHECK-LABEL: define ptr @alloca_dynarray_of_dynchar2(
249 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
250 // CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
251 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
252 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
253 // CHECK: alloca i16, i64 %[[prod3]]
254 func.func @alloca_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.ref<!fir.array<?x?x!fir.char<2,?>>> {
255 %1 = fir.alloca !fir.array<?x?x!fir.char<2,?>>(%l : i32), %e, %e
256 return %1 : !fir.ref<!fir.array<?x?x!fir.char<2,?>>>
257 }
258
259 // CHECK-LABEL: define ptr @allocmem_dynarray_of_dynchar(
260 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
261 // CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
262 // CHECK: %[[prod2:.*]] = mul i64 6, %[[prod1]]
263 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
264 // CHECK: call ptr @malloc(i64 %[[prod3]])
265 func.func @allocmem_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,?>>> {
266 %1 = fir.allocmem !fir.array<3x?x!fir.char<2,?>>(%l : i32), %e
267 return %1 : !fir.heap<!fir.array<3x?x!fir.char<2,?>>>
268 }
269
270 // CHECK-LABEL: define ptr @allocmem_dynarray_of_dynchar2(
271 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
272 // CHECK: %[[a:.*]] = sext i32 %[[len]] to i64
273 // CHECK: %[[prod1:.*]] = mul i64 2, %[[a]]
274 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
275 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
276 // CHECK: call ptr @malloc(i64 %[[prod3]])
277 func.func @allocmem_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,?>>> {
278 %1 = fir.allocmem !fir.array<?x?x!fir.char<2,?>>(%l : i32), %e, %e
279 return %1 : !fir.heap<!fir.array<?x?x!fir.char<2,?>>>
280 }
281
282 // CHECK-LABEL: define ptr @alloca_array_with_holes_nonchar(
283 // CHECK-SAME: i64 %[[a:.*]], i64 %[[b:.*]])
284 // CHECK: %[[prod1:.*]] = mul i64 15, %[[a]]
285 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[b]]
286 // CHECK: alloca [4 x i32], i64 %[[prod2]]
287 func.func @alloca_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.ref<!fir.array<4x?x3x?x5xi32>> {
288 %a = fir.alloca !fir.array<4x?x3x?x5xi32>, %0, %1
289 return %a : !fir.ref<!fir.array<4x?x3x?x5xi32>>
290 }
291
292 // CHECK-LABEL: define ptr @alloca_array_with_holes_char(
293 // CHECK-SAME: i64 %[[e:.*]])
294 // CHECK: %[[mul:.*]] = mul i64 4, %[[e]]
295 // CHECK: alloca [3 x [10 x i16]], i64 %[[mul]]
296 func.func @alloca_array_with_holes_char(%e: index) -> !fir.ref<!fir.array<3x?x4x!fir.char<2,10>>> {
297 %1 = fir.alloca !fir.array<3x?x4x!fir.char<2,10>>, %e
298 return %1 : !fir.ref<!fir.array<3x?x4x!fir.char<2,10>>>
299 }
300
301 // CHECK-LABEL: define ptr @alloca_array_with_holes_dynchar(
302 // CHECK-SAME: i64 %[[len:.*]], i64 %[[extent:.*]])
303 // CHECK: %[[a:.*]] = mul i64 %[[len]], 12
304 // CHECK: %[[b:.*]] = mul i64 %[[a]], %[[extent]]
305 // CHECK: alloca i16, i64 %[[b]]
306 func.func @alloca_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.ref<!fir.array<3x?x4x!fir.char<2,?>>> {
307 %1 = fir.alloca !fir.array<3x?x4x!fir.char<2,?>>(%arg0 : index), %arg1
308 return %1 : !fir.ref<!fir.array<3x?x4x!fir.char<2,?>>>
309 }
310
311 // CHECK-LABEL: define ptr @allocmem_array_with_holes_nonchar(
312 // CHECK-SAME: i64 %[[e1:.*]], i64 %[[e2:.*]])
313 // CHECK: %[[a:.*]] = mul i64 240, %[[e1]]
314 // CHECK: %[[b:.*]] = mul i64 %3, %[[e2]]
315 // CHECK: call ptr @malloc(i64 %[[b]])
316 func.func @allocmem_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.heap<!fir.array<4x?x3x?x5xi32>> {
317 %a = fir.allocmem !fir.array<4x?x3x?x5xi32>, %0, %1
318 return %a : !fir.heap<!fir.array<4x?x3x?x5xi32>>
319 }
320
321 // CHECK-LABEL: define ptr @allocmem_array_with_holes_char(
322 // CHECK-SAME: i64 %[[e:.*]])
323 // CHECK: %[[mul:.*]] = mul i64 240, %[[e]]
324 // CHECK: call ptr @malloc(i64 %[[mul]])
325 func.func @allocmem_array_with_holes_char(%e: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,10>>> {
326 %1 = fir.allocmem !fir.array<3x?x4x!fir.char<2,10>>, %e
327 return %1 : !fir.heap<!fir.array<3x?x4x!fir.char<2,10>>>
328 }
329
330 // CHECK-LABEL: define ptr @allocmem_array_with_holes_dynchar(
331 // CHECK-SAME: i64 %[[len:.*]], i64 %[[extent:.*]])
332 // CHECK: %[[a:.*]] = mul i64 24, %[[len]]
333 // CHECK: %[[b:.*]] = mul i64 %[[a]], %[[extent]]
334 // CHECK: call ptr @malloc(i64 %[[b]])
335 func.func @allocmem_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,?>>> {
336 %1 = fir.allocmem !fir.array<3x?x4x!fir.char<2,?>>(%arg0 : index), %arg1
337 return %1 : !fir.heap<!fir.array<3x?x4x!fir.char<2,?>>>
338 }
339
340 // CHECK-LABEL: define void @alloca_unlimited_polymorphic_box
341 // CHECK: %[[VAL_1:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]], ptr, [1 x i64] }, i64 1
342 // CHECK: %[[VAL_0:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, ptr, [1 x i64] }, i64 1
343 // CHECK: %[[VAL_3:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]], ptr, [1 x i64] }, i64 1
344 // CHECK: %[[VAL_2:.*]] = alloca { ptr, i64, i32, i8, i8, i8, i8, ptr, [1 x i64] }, i64 1
345
346 func.func @alloca_unlimited_polymorphic_box() {
347 %0 = fir.alloca !fir.class<none>
348 %1 = fir.alloca !fir.class<!fir.array<?xnone>>
349 %2 = fir.alloca !fir.box<none>
350 %3 = fir.alloca !fir.box<!fir.array<?xnone>>
351 return
352 }
353 // Note: allocmem of fir.box are not possible (fir::HeapType::verify does not
354 // accept box types), so there is no equivalent of
355 // alloca_unlimited_polymorphic_box for allocmem.