| blob | 995d2545c63590df77bd0b104c97aa9f6284df33 |
1 ; RUN: llc < %s -mtriple=arm64-linux-gnu | FileCheck %s
2 ;
3 ; Note: Print verbose stackmaps using -debug-only=stackmaps.
5 ; CHECK-LABEL: .section .llvm_stackmaps
6 ; CHECK-NEXT: __LLVM_StackMaps:
7 ; Header
8 ; CHECK-NEXT: .byte 3
9 ; CHECK-NEXT: .byte 0
10 ; CHECK-NEXT: .hword 0
11 ; Num Functions
12 ; CHECK-NEXT: .word 15
13 ; Num LargeConstants
14 ; CHECK-NEXT: .word 4
15 ; Num Callsites
16 ; CHECK-NEXT: .word 22
18 ; Functions and stack size
19 ; CHECK-NEXT: .xword constantargs
20 ; CHECK-NEXT: .xword 16
21 ; CHECK-NEXT: .xword 1
22 ; CHECK-NEXT: .xword osrinline
23 ; CHECK-NEXT: .xword 32
24 ; CHECK-NEXT: .xword 1
25 ; CHECK-NEXT: .xword osrcold
26 ; CHECK-NEXT: .xword 16
27 ; CHECK-NEXT: .xword 1
28 ; CHECK-NEXT: .xword propertyRead
29 ; CHECK-NEXT: .xword 16
30 ; CHECK-NEXT: .xword 1
31 ; CHECK-NEXT: .xword propertyWrite
32 ; CHECK-NEXT: .xword 16
33 ; CHECK-NEXT: .xword 1
34 ; CHECK-NEXT: .xword jsVoidCall
35 ; CHECK-NEXT: .xword 16
36 ; CHECK-NEXT: .xword 1
37 ; CHECK-NEXT: .xword jsIntCall
38 ; CHECK-NEXT: .xword 16
39 ; CHECK-NEXT: .xword 1
40 ; CHECK-NEXT: .xword spilledValue
41 ; CHECK-NEXT: .xword 160
42 ; CHECK-NEXT: .xword 1
43 ; CHECK-NEXT: .xword liveConstant
44 ; CHECK-NEXT: .xword 16
45 ; CHECK-NEXT: .xword 1
46 ; CHECK-NEXT: .xword directFrameIdx
47 ; CHECK-NEXT: .xword 64
48 ; CHECK-NEXT: .xword 2
49 ; CHECK-NEXT: .xword longid
50 ; CHECK-NEXT: .xword 16
51 ; CHECK-NEXT: .xword 4
52 ; CHECK-NEXT: .xword statepoint_longid
53 ; CHECK-NEXT: .xword 16
54 ; CHECK-NEXT: .xword 4
55 ; CHECK-NEXT: .xword clobberLR
56 ; CHECK-NEXT: .xword 112
57 ; CHECK-NEXT: .xword 1
58 ; CHECK-NEXT: .xword needsStackRealignment
59 ; CHECK-NEXT: .xword -1
60 ; CHECK-NEXT: .xword 1
61 ; CHECK-NEXT: .xword floats
62 ; CHECK-NEXT: .xword 32
63 ; CHECK-NEXT: .xword 1
65 ; Large Constants
66 ; CHECK-NEXT: .xword 2147483648
67 ; CHECK-NEXT: .xword 4294967295
68 ; CHECK-NEXT: .xword 4294967296
69 ; CHECK-NEXT: .xword 4294967297
71 ; Callsites
72 ; Constant arguments
73 ;
74 ; CHECK-NEXT: .xword 1
75 ; CHECK-NEXT: .word .L{{.*}}-constantargs
76 ; CHECK-NEXT: .hword 0
77 ; CHECK-NEXT: .hword 14
78 ; SmallConstant
79 ; CHECK-NEXT: .byte 4
80 ; CHECK-NEXT: .byte 0
81 ; CHECK-NEXT: .hword 8
82 ; CHECK-NEXT: .hword 0
83 ; CHECK-NEXT: .hword 0
84 ; CHECK-NEXT: .word 65535
85 ; SmallConstant
86 ; CHECK-NEXT: .byte 4
87 ; CHECK-NEXT: .byte 0
88 ; CHECK-NEXT: .hword 8
89 ; CHECK-NEXT: .hword 0
90 ; CHECK-NEXT: .hword 0
91 ; CHECK-NEXT: .word 65535
92 ; SmallConstant
93 ; CHECK-NEXT: .byte 4
94 ; CHECK-NEXT: .byte 0
95 ; CHECK-NEXT: .hword 8
96 ; CHECK-NEXT: .hword 0
97 ; CHECK-NEXT: .hword 0
98 ; CHECK-NEXT: .word 65536
99 ; SmallConstant
100 ; CHECK-NEXT: .byte 4
101 ; CHECK-NEXT: .byte 0
102 ; CHECK-NEXT: .hword 8
103 ; CHECK-NEXT: .hword 0
104 ; CHECK-NEXT: .hword 0
105 ; CHECK-NEXT: .word 2000000000
106 ; SmallConstant
107 ; CHECK-NEXT: .byte 4
108 ; CHECK-NEXT: .byte 0
109 ; CHECK-NEXT: .hword 8
110 ; CHECK-NEXT: .hword 0
111 ; CHECK-NEXT: .hword 0
112 ; CHECK-NEXT: .word 2147483647
113 ; SmallConstant
114 ; CHECK-NEXT: .byte 4
115 ; CHECK-NEXT: .byte 0
116 ; CHECK-NEXT: .hword 8
117 ; CHECK-NEXT: .hword 0
118 ; CHECK-NEXT: .hword 0
119 ; CHECK-NEXT: .word -1
120 ; SmallConstant
121 ; CHECK-NEXT: .byte 4
122 ; CHECK-NEXT: .byte 0
123 ; CHECK-NEXT: .hword 8
124 ; CHECK-NEXT: .hword 0
125 ; CHECK-NEXT: .hword 0
126 ; CHECK-NEXT: .word -1
127 ; SmallConstant
128 ; CHECK-NEXT: .byte 4
129 ; CHECK-NEXT: .byte 0
130 ; CHECK-NEXT: .hword 8
131 ; CHECK-NEXT: .hword 0
132 ; CHECK-NEXT: .hword 0
133 ; CHECK-NEXT: .word 0
134 ; LargeConstant at index 0
135 ; CHECK-NEXT: .byte 5
136 ; CHECK-NEXT: .byte 0
137 ; CHECK-NEXT: .hword 8
138 ; CHECK-NEXT: .hword 0
139 ; CHECK-NEXT: .hword 0
140 ; CHECK-NEXT: .word 0
141 ; LargeConstant at index 1
142 ; CHECK-NEXT: .byte 5
143 ; CHECK-NEXT: .byte 0
144 ; CHECK-NEXT: .hword 8
145 ; CHECK-NEXT: .hword 0
146 ; CHECK-NEXT: .hword 0
147 ; CHECK-NEXT: .word 1
148 ; LargeConstant at index 2
149 ; CHECK-NEXT: .byte 5
150 ; CHECK-NEXT: .byte 0
151 ; CHECK-NEXT: .hword 8
152 ; CHECK-NEXT: .hword 0
153 ; CHECK-NEXT: .hword 0
154 ; CHECK-NEXT: .word 2
155 ; SmallConstant
156 ; CHECK-NEXT: .byte 4
157 ; CHECK-NEXT: .byte 0
158 ; CHECK-NEXT: .hword 8
159 ; CHECK-NEXT: .hword 0
160 ; CHECK-NEXT: .hword 0
161 ; CHECK-NEXT: .word -1
162 ; SmallConstant
163 ; CHECK-NEXT: .byte 4
164 ; CHECK-NEXT: .byte 0
165 ; CHECK-NEXT: .hword 8
166 ; CHECK-NEXT: .hword 0
167 ; CHECK-NEXT: .hword 0
168 ; CHECK-NEXT: .word 66
169 ; LargeConstant at index 2
170 ; CHECK-NEXT: .byte 5
171 ; CHECK-NEXT: .byte 0
172 ; CHECK-NEXT: .hword 8
173 ; CHECK-NEXT: .hword 0
174 ; CHECK-NEXT: .hword 0
175 ; CHECK-NEXT: .word 3
177 define void @constantargs() {
178 entry:
179 %0 = inttoptr i64 12345 to ptr
180 tail call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 1, i32 16, ptr %0, i32 0, i16 65535, i16 -1, i32 65536, i32 2000000000, i32 2147483647, i32 -1, i32 4294967295, i32 4294967296, i64 2147483648, i64 4294967295, i64 4294967296, i64 -1, i128 66, i128 4294967297)
181 ret void
182 }
184 ; Inline OSR Exit
185 ;
186 ; CHECK-LABEL: .word .L{{.*}}-osrinline
187 ; CHECK-NEXT: .hword 0
188 ; CHECK-NEXT: .hword 2
189 ; CHECK-NEXT: .byte 1
190 ; CHECK-NEXT: .byte 0
191 ; CHECK-NEXT: .hword 8
192 ; CHECK-NEXT: .hword {{[0-9]+}}
193 ; CHECK-NEXT: .hword 0
194 ; CHECK-NEXT: .word 0
195 ; CHECK-NEXT: .byte 1
196 ; CHECK-NEXT: .byte 0
197 ; CHECK-NEXT: .hword 8
198 ; CHECK-NEXT: .hword {{[0-9]+}}
199 ; CHECK-NEXT: .hword 0
200 ; CHECK-NEXT: .word 0
201 define void @osrinline(i64 %a, i64 %b) {
202 entry:
203 ; Runtime void->void call.
204 call void inttoptr (i64 -559038737 to ptr)()
205 ; Followed by inline OSR patchpoint with 12-byte shadow and 2 live vars.
206 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 3, i32 12, i64 %a, i64 %b)
207 ret void
208 }
210 ; Cold OSR Exit
211 ;
212 ; 2 live variables in register.
213 ;
214 ; CHECK-LABEL: .word .L{{.*}}-osrcold
215 ; CHECK-NEXT: .hword 0
216 ; CHECK-NEXT: .hword 2
217 ; CHECK-NEXT: .byte 1
218 ; CHECK-NEXT: .byte 0
219 ; CHECK-NEXT: .hword 8
220 ; CHECK-NEXT: .hword {{[0-9]+}}
221 ; CHECK-NEXT: .hword 0
222 ; CHECK-NEXT: .word 0
223 ; CHECK-NEXT: .byte 1
224 ; CHECK-NEXT: .byte 0
225 ; CHECK-NEXT: .hword 8
226 ; CHECK-NEXT: .hword {{[0-9]+}}
227 ; CHECK-NEXT: .hword 0
228 ; CHECK-NEXT: .word 0
229 define void @osrcold(i64 %a, i64 %b) {
230 entry:
231 %test = icmp slt i64 %a, %b
232 br i1 %test, label %ret, label %cold
233 cold:
234 ; OSR patchpoint with 12-byte nop-slide and 2 live vars.
235 %thunk = inttoptr i64 3735928559 to ptr
236 call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 4, i32 16, ptr %thunk, i32 0, i64 %a, i64 %b)
237 unreachable
238 ret:
239 ret void
240 }
242 ; Property Read
243 ; CHECK-LABEL: .word .L{{.*}}-propertyRead
244 ; CHECK-NEXT: .hword 0
245 ; CHECK-NEXT: .hword 2
246 ; CHECK-NEXT: .byte 1
247 ; CHECK-NEXT: .byte 0
248 ; CHECK-NEXT: .hword 8
249 ; CHECK-NEXT: .hword {{[0-9]+}}
250 ; CHECK-NEXT: .hword 0
251 ; CHECK-NEXT: .word 0
252 ; CHECK-NEXT: .byte 1
253 ; CHECK-NEXT: .byte 0
254 ; CHECK-NEXT: .hword 8
255 ; CHECK-NEXT: .hword {{[0-9]+}}
256 ; CHECK-NEXT: .hword 0
257 ; CHECK-NEXT: .word 0
258 define i64 @propertyRead(ptr %obj) {
259 entry:
260 %resolveRead = inttoptr i64 3735928559 to ptr
261 %result = call anyregcc i64 (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.i64(i64 5, i32 16, ptr %resolveRead, i32 1, ptr %obj)
262 %add = add i64 %result, 3
263 ret i64 %add
264 }
266 ; Property Write
267 ; CHECK-LABEL: .word .L{{.*}}-propertyWrite
268 ; CHECK-NEXT: .hword 0
269 ; CHECK-NEXT: .hword 2
270 ; CHECK-NEXT: .byte 1
271 ; CHECK-NEXT: .byte 0
272 ; CHECK-NEXT: .hword 8
273 ; CHECK-NEXT: .hword {{[0-9]+}}
274 ; CHECK-NEXT: .hword 0
275 ; CHECK-NEXT: .word 0
276 ; CHECK-NEXT: .byte 1
277 ; CHECK-NEXT: .byte 0
278 ; CHECK-NEXT: .hword 8
279 ; CHECK-NEXT: .hword {{[0-9]+}}
280 ; CHECK-NEXT: .hword 0
281 ; CHECK-NEXT: .word 0
282 define void @propertyWrite(i64 %dummy1, ptr %obj, i64 %dummy2, i64 %a) {
283 entry:
284 %resolveWrite = inttoptr i64 3735928559 to ptr
285 call anyregcc void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 6, i32 16, ptr %resolveWrite, i32 2, ptr %obj, i64 %a)
286 ret void
287 }
289 ; Void JS Call
290 ;
291 ; 2 live variables in registers.
292 ;
293 ; CHECK-LABEL: .word .L{{.*}}-jsVoidCall
294 ; CHECK-NEXT: .hword 0
295 ; CHECK-NEXT: .hword 2
296 ; CHECK-NEXT: .byte 1
297 ; CHECK-NEXT: .byte 0
298 ; CHECK-NEXT: .hword 8
299 ; CHECK-NEXT: .hword {{[0-9]+}}
300 ; CHECK-NEXT: .hword 0
301 ; CHECK-NEXT: .word 0
302 ; CHECK-NEXT: .byte 1
303 ; CHECK-NEXT: .byte 0
304 ; CHECK-NEXT: .hword 8
305 ; CHECK-NEXT: .hword {{[0-9]+}}
306 ; CHECK-NEXT: .hword 0
307 ; CHECK-NEXT: .word 0
308 define void @jsVoidCall(i64 %dummy1, ptr %obj, i64 %arg, i64 %l1, i64 %l2) {
309 entry:
310 %resolveCall = inttoptr i64 3735928559 to ptr
311 call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 7, i32 16, ptr %resolveCall, i32 2, ptr %obj, i64 %arg, i64 %l1, i64 %l2)
312 ret void
313 }
315 ; i64 JS Call
316 ;
317 ; 2 live variables in registers.
318 ;
319 ; CHECK-LABEL: .word .L{{.*}}-jsIntCall
320 ; CHECK-NEXT: .hword 0
321 ; CHECK-NEXT: .hword 2
322 ; CHECK-NEXT: .byte 1
323 ; CHECK-NEXT: .byte 0
324 ; CHECK-NEXT: .hword 8
325 ; CHECK-NEXT: .hword {{[0-9]+}}
326 ; CHECK-NEXT: .hword 0
327 ; CHECK-NEXT: .word 0
328 ; CHECK-NEXT: .byte 1
329 ; CHECK-NEXT: .byte 0
330 ; CHECK-NEXT: .hword 8
331 ; CHECK-NEXT: .hword {{[0-9]+}}
332 ; CHECK-NEXT: .hword 0
333 ; CHECK-NEXT: .word 0
334 define i64 @jsIntCall(i64 %dummy1, ptr %obj, i64 %arg, i64 %l1, i64 %l2) {
335 entry:
336 %resolveCall = inttoptr i64 3735928559 to ptr
337 %result = call i64 (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.i64(i64 8, i32 16, ptr %resolveCall, i32 2, ptr %obj, i64 %arg, i64 %l1, i64 %l2)
338 %add = add i64 %result, 3
339 ret i64 %add
340 }
342 ; Spilled stack map values.
343 ;
344 ; Verify 28 stack map entries.
345 ;
346 ; CHECK-LABEL: .word .L{{.*}}-spilledValue
347 ; CHECK-NEXT: .hword 0
348 ; CHECK-NEXT: .hword 28
349 ;
350 ; Check that at least one is a spilled entry from RBP.
351 ; Location: Indirect RBP + ...
352 ; CHECK: .byte 3
353 ; CHECK-NEXT: .byte 0
354 ; CHECK-NEXT: .hword 8
355 ; CHECK-NEXT: .hword 29
356 ; CHECK-NEXT: .hword 0
357 ; CHECK-NEXT: .word
358 define void @spilledValue(i64 %arg0, i64 %arg1, i64 %arg2, i64 %arg3, i64 %arg4, i64 %l0, i64 %l1, i64 %l2, i64 %l3, i64 %l4, i64 %l5, i64 %l6, i64 %l7, i64 %l8, i64 %l9, i64 %l10, i64 %l11, i64 %l12, i64 %l13, i64 %l14, i64 %l15, i64 %l16, i64 %l17, i64 %l18, i64 %l19, i64 %l20, i64 %l21, i64 %l22, i64 %l23, i64 %l24, i64 %l25, i64 %l26, i64 %l27) {
359 entry:
360 call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 11, i32 20, ptr null, i32 5, i64 %arg0, i64 %arg1, i64 %arg2, i64 %arg3, i64 %arg4, i64 %l0, i64 %l1, i64 %l2, i64 %l3, i64 %l4, i64 %l5, i64 %l6, i64 %l7, i64 %l8, i64 %l9, i64 %l10, i64 %l11, i64 %l12, i64 %l13, i64 %l14, i64 %l15, i64 %l16, i64 %l17, i64 %l18, i64 %l19, i64 %l20, i64 %l21, i64 %l22, i64 %l23, i64 %l24, i64 %l25, i64 %l26, i64 %l27)
361 ret void
362 }
364 ; Map a constant value.
365 ;
366 ; CHECK-LABEL: .word .L{{.*}}-liveConstant
367 ; CHECK-NEXT: .hword 0
368 ; 1 location
369 ; CHECK-NEXT: .hword 1
370 ; Loc 0: SmallConstant
371 ; CHECK-NEXT: .byte 4
372 ; CHECK-NEXT: .byte 0
373 ; CHECK-NEXT: .hword 8
374 ; CHECK-NEXT: .hword 0
375 ; CHECK-NEXT: .hword 0
376 ; CHECK-NEXT: .word 33
378 define void @liveConstant() {
379 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 15, i32 4, i32 33)
380 ret void
381 }
383 ; Directly map an alloca's address.
384 ;
385 ; Callsite 16
386 ; CHECK-LABEL: .word .L{{.*}}-directFrameIdx
387 ; CHECK-NEXT: .hword 0
388 ; 1 location
389 ; CHECK-NEXT: .hword 1
390 ; Loc 0: Direct RBP - ofs
391 ; CHECK-NEXT: .byte 2
392 ; CHECK-NEXT: .byte 0
393 ; CHECK-NEXT: .hword 8
394 ; CHECK-NEXT: .hword 29
395 ; CHECK-NEXT: .hword 0
396 ; CHECK-NEXT: .word
398 ; Callsite 17
399 ; CHECK-LABEL: .word .L{{.*}}-directFrameIdx
400 ; CHECK-NEXT: .hword 0
401 ; 2 locations
402 ; CHECK-NEXT: .hword 2
403 ; Loc 0: Direct RBP - ofs
404 ; CHECK-NEXT: .byte 2
405 ; CHECK-NEXT: .byte 0
406 ; CHECK-NEXT: .hword 8
407 ; CHECK-NEXT: .hword 29
408 ; CHECK-NEXT: .hword 0
409 ; CHECK-NEXT: .word
410 ; Loc 1: Direct RBP - ofs
411 ; CHECK-NEXT: .byte 2
412 ; CHECK-NEXT: .byte 0
413 ; CHECK-NEXT: .hword 8
414 ; CHECK-NEXT: .hword 29
415 ; CHECK-NEXT: .hword 0
416 ; CHECK-NEXT: .word
417 define void @directFrameIdx() {
418 entry:
419 %metadata1 = alloca i64, i32 3, align 8
420 store i64 11, ptr %metadata1
421 store i64 12, ptr %metadata1
422 store i64 13, ptr %metadata1
423 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 16, i32 0, ptr %metadata1)
424 %metadata2 = alloca i8, i32 4, align 8
425 %metadata3 = alloca i16, i32 4, align 8
426 call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 17, i32 4, ptr null, i32 0, ptr %metadata2, ptr %metadata3)
427 ret void
428 }
430 ; Test a 64-bit ID.
431 ;
432 ; CHECK: .xword 4294967295
433 ; CHECK-LABEL: .word .L{{.*}}-longid
434 ; CHECK: .xword 4294967296
435 ; CHECK-LABEL: .word .L{{.*}}-longid
436 ; CHECK: .xword 9223372036854775807
437 ; CHECK-LABEL: .word .L{{.*}}-longid
438 ; CHECK: .xword -1
439 ; CHECK-LABEL: .word .L{{.*}}-longid
440 define void @longid() {
441 entry:
442 tail call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 4294967295, i32 0, ptr null, i32 0)
443 tail call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 4294967296, i32 0, ptr null, i32 0)
444 tail call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 9223372036854775807, i32 0, ptr null, i32 0)
445 tail call void (i64, i32, ptr, i32, ...) @llvm.experimental.patchpoint.void(i64 -1, i32 0, ptr null, i32 0)
446 ret void
447 }
449 ; Test a 64-bit ID for statepoint.
450 ;
451 ; CHECK: .xword 4294967295
452 ; CHECK-LABEL: .word .L{{.*}}-statepoint_longid
453 ; CHECK: .xword 4294967296
454 ; CHECK-LABEL: .word .L{{.*}}-statepoint_longid
455 ; CHECK: .xword 9223372036854775807
456 ; CHECK-LABEL: .word .L{{.*}}-statepoint_longid
457 ; CHECK: .xword -1
458 ; CHECK-LABEL: .word .L{{.*}}-statepoint_longid
459 define void @statepoint_longid() gc "statepoint-example" {
460 entry:
461 %safepoint_token1 = tail call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 4294967295, i32 0, ptr elementtype(void ()) @return_void, i32 0, i32 0, i32 0, i32 0)
462 %safepoint_token2 = tail call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 4294967296, i32 0, ptr elementtype(void ()) @return_void, i32 0, i32 0, i32 0, i32 0)
463 %safepoint_token3 = tail call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 9223372036854775807, i32 0, ptr elementtype(void ()) @return_void, i32 0, i32 0, i32 0, i32 0)
464 %safepoint_token4 = tail call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 -1, i32 0, ptr elementtype(void ()) @return_void, i32 0, i32 0, i32 0, i32 0)
465 ret void
466 }
467 declare void @return_void()
469 ; Map a value when R11 is the only free register.
470 ; The scratch register should not be used for a live stackmap value.
471 ;
472 ; CHECK-LABEL: .word .L{{.*}}-clobberLR
473 ; CHECK-NEXT: .hword 0
474 ; 1 location
475 ; CHECK-NEXT: .hword 1
476 ; Loc 0: Indirect fp - offset
477 ; CHECK-NEXT: .byte 3
478 ; CHECK-NEXT: .byte 0
479 ; CHECK-NEXT: .hword 4
480 ; CHECK-NEXT: .hword 29
481 ; CHECK-NEXT: .hword 0
482 ; CHECK-NEXT: .word -{{[0-9]+}}
483 define void @clobberLR(i32 %a) {
484 tail call void asm sideeffect "nop", "~{x0},~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7},~{x8},~{x9},~{x10},~{x11},~{x12},~{x13},~{x14},~{x15},~{x16},~{x17},~{x18},~{x19},~{x20},~{x21},~{x22},~{x23},~{x24},~{x25},~{x26},~{x27},~{x28},~{x29},~{x31}"() nounwind
485 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 16, i32 8, i32 %a)
486 ret void
487 }
489 ; A stack frame which needs to be realigned at runtime (to meet alignment
490 ; criteria for values on the stack) does not have a fixed frame size.
491 ; CHECK-LABEL: .word .L{{.*}}-needsStackRealignment
492 ; CHECK-NEXT: .hword 0
493 ; 0 locations
494 ; CHECK-NEXT: .hword 0
495 define void @needsStackRealignment() {
496 %val = alloca i64, i32 3, align 128
497 tail call void (...) @escape_values(ptr %val)
498 ; Note: Adding any non-constant to the stackmap would fail because we
499 ; expected to be able to address off the frame pointer. In a realigned
500 ; frame, we must use the stack pointer instead. This is a separate bug.
501 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 0, i32 0)
502 ret void
503 }
504 declare void @escape_values(...)
506 ; CHECK-LABEL: .word .L{{.*}}-floats
507 ; CHECK-NEXT: .hword 0
508 ; Num Locations
509 ; CHECK-NEXT: .hword 6
510 ; Loc 0: constant float stored to FP register
511 ; CHECK-NEXT: .byte 1
512 ; CHECK-NEXT: .byte 0
513 ; CHECK-NEXT: .hword 4
514 ; CHECK-NEXT: .hword {{.*}}
515 ; CHECK-NEXT: .hword 0
516 ; CHECK-NEXT: .word 0
517 ; Loc 0: constant double stored to FP register
518 ; CHECK-NEXT: .byte 1
519 ; CHECK-NEXT: .byte 0
520 ; CHECK-NEXT: .hword 8
521 ; CHECK-NEXT: .hword {{.*}}
522 ; CHECK-NEXT: .hword 0
523 ; CHECK-NEXT: .word 0
524 ; Loc 1: float value in FP register
525 ; CHECK-NEXT: .byte 1
526 ; CHECK-NEXT: .byte 0
527 ; CHECK-NEXT: .hword 4
528 ; CHECK-NEXT: .hword {{.*}}
529 ; CHECK-NEXT: .hword 0
530 ; CHECK-NEXT: .word 0
531 ; Loc 2: double value in FP register
532 ; CHECK-NEXT: .byte 1
533 ; CHECK-NEXT: .byte 0
534 ; CHECK-NEXT: .hword 8
535 ; CHECK-NEXT: .hword {{.*}}
536 ; CHECK-NEXT: .hword 0
537 ; CHECK-NEXT: .word 0
538 ; Loc 3: float on stack
539 ; CHECK-NEXT: .byte 2
540 ; CHECK-NEXT: .byte 0
541 ; CHECK-NEXT: .hword 8
542 ; CHECK-NEXT: .hword {{.*}}
543 ; CHECK-NEXT: .hword 0
544 ; CHECK-NEXT: .word -{{.*}}
545 ; Loc 4: double on stack
546 ; CHECK-NEXT: .byte 2
547 ; CHECK-NEXT: .byte 0
548 ; CHECK-NEXT: .hword 8
549 ; CHECK-NEXT: .hword {{.*}}
550 ; CHECK-NEXT: .hword 0
551 ; CHECK-NEXT: .word -{{.*}}
552 define void @floats(float %f, double %g) {
553 %ff = alloca float
554 %gg = alloca double
555 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 888, i32 0, float 1.25,
556 double 1.5, float %f, double %g, ptr %ff, ptr %gg)
557 ret void
558 }
560 declare void @llvm.experimental.stackmap(i64, i32, ...)
561 declare void @llvm.experimental.patchpoint.void(i64, i32, ptr, i32, ...)
562 declare i64 @llvm.experimental.patchpoint.i64(i64, i32, ptr, i32, ...)
563 declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)