xref: /llvm-project/llvm/test/CodeGen/AArch64/stackmap.ll (revision 0ef743778000e7d213e53e6a7b998e1c34a28701) 
1; RUN: llc < %s -mtriple=arm64-linux-gnu | FileCheck %s
2;
3; Note: Print verbose stackmaps using -debug-only=stackmaps.
4
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
17
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
64
65; Large Constants
66; CHECK-NEXT:   .xword   2147483648
67; CHECK-NEXT:   .xword   4294967295
68; CHECK-NEXT:   .xword   4294967296
69; CHECK-NEXT:   .xword   4294967297
70
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
176
177define void @constantargs() {
178entry:
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}
183
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
201define void @osrinline(i64 %a, i64 %b) {
202entry:
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}
209
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
229define void @osrcold(i64 %a, i64 %b) {
230entry:
231  %test = icmp slt i64 %a, %b
232  br i1 %test, label %ret, label %cold
233cold:
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
238ret:
239  ret void
240}
241
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
258define i64 @propertyRead(ptr %obj) {
259entry:
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}
265
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
282define void @propertyWrite(i64 %dummy1, ptr %obj, i64 %dummy2, i64 %a) {
283entry:
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}
288
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
308define void @jsVoidCall(i64 %dummy1, ptr %obj, i64 %arg, i64 %l1, i64 %l2) {
309entry:
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}
314
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
334define i64 @jsIntCall(i64 %dummy1, ptr %obj, i64 %arg, i64 %l1, i64 %l2) {
335entry:
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}
341
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
358define 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) {
359entry:
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}
363
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
377
378define void @liveConstant() {
379  tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 15, i32 4, i32 33)
380  ret void
381}
382
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
397
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
417define void @directFrameIdx() {
418entry:
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}
429
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
440define void @longid() {
441entry:
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}
448
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
459define void @statepoint_longid() gc "statepoint-example" {
460entry:
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}
467declare void @return_void()
468
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]+}}
483define 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}
488
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
495define 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}
504declare void @escape_values(...)
505
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   -{{.*}}
552define 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}
559
560declare void @llvm.experimental.stackmap(i64, i32, ...)
561declare void @llvm.experimental.patchpoint.void(i64, i32, ptr, i32, ...)
562declare i64 @llvm.experimental.patchpoint.i64(i64, i32, ptr, i32, ...)
563declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
564