Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 00ed9964c65962e2afc8e3c83a2f7114b0ce25a0 / . / llvm / test / CodeGen / ARM64 / stackmap.ll
blob: cc4e7f2fd39a97ad5a5f5a8dff2e4382c2242060 [file] [log] [blame]
Tim Northover00ed9962014-03-29 10:18:08 +0000[diff] [blame^]1; RUN: llc < %s -mtriple=arm64-apple-darwin | FileCheck %s
2;
3; Note: Print verbose stackmaps using -debug-only=stackmaps.
4
5; We are not getting the correct stack alignment when cross compiling for arm64.
6; So specify a datalayout here.
7target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
8
9; CHECK-LABEL: .section __LLVM_STACKMAPS,__llvm_stackmaps
10; CHECK-NEXT: __LLVM_StackMaps:
11; CHECK-NEXT: .long 0
12; Num Functions
13; CHECK-NEXT: .long 11
14; CHECK-NEXT: .long _constantargs
15; CHECK-NEXT: .long 16
16; CHECK-NEXT: .long _osrinline
17; CHECK-NEXT: .long 32
18; CHECK-NEXT: .long _osrcold
19; CHECK-NEXT: .long 16
20; CHECK-NEXT: .long _propertyRead
21; CHECK-NEXT: .long 16
22; CHECK-NEXT: .long _propertyWrite
23; CHECK-NEXT: .long 16
24; CHECK-NEXT: .long _jsVoidCall
25; CHECK-NEXT: .long 16
26; CHECK-NEXT: .long _jsIntCall
27; CHECK-NEXT: .long 16
28; CHECK-NEXT: .long _spilledValue
29; CHECK-NEXT: .long 160
30; CHECK-NEXT: .long _spilledStackMapValue
31; CHECK-NEXT: .long 128
32; CHECK-NEXT: .long _liveConstant
33; CHECK-NEXT: .long 16
34; CHECK-NEXT: .long _clobberLR
35; CHECK-NEXT: .long 112
36; Num LargeConstants
37; CHECK-NEXT: .long 2
38; CHECK-NEXT: .quad 4294967295
39; CHECK-NEXT: .quad 4294967296
40; Num Callsites
41; CHECK-NEXT: .long 11
42
43; Constant arguments
44;
45; CHECK-NEXT: .quad 1
46; CHECK-NEXT: .long L{{.*}}-_constantargs
47; CHECK-NEXT: .short 0
48; CHECK-NEXT: .short 4
49; SmallConstant
50; CHECK-NEXT: .byte 4
51; CHECK-NEXT: .byte 8
52; CHECK-NEXT: .short 0
53; CHECK-NEXT: .long 65535
54; SmallConstant
55; CHECK-NEXT: .byte 4
56; CHECK-NEXT: .byte 8
57; CHECK-NEXT: .short 0
58; CHECK-NEXT: .long 65536
59; SmallConstant
60; CHECK-NEXT: .byte 5
61; CHECK-NEXT: .byte 8
62; CHECK-NEXT: .short 0
63; CHECK-NEXT: .long 0
64; LargeConstant at index 0
65; CHECK-NEXT: .byte 5
66; CHECK-NEXT: .byte 8
67; CHECK-NEXT: .short 0
68; CHECK-NEXT: .long 1
69
70define void @constantargs() {
71entry:
72 %0 = inttoptr i64 244837814094590 to i8*
73 tail call void (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.void(i64 1, i32 20, i8* %0, i32 0, i64 65535, i64 65536, i64 4294967295, i64 4294967296)
74 ret void
75}
76
77; Inline OSR Exit
78;
79; CHECK-LABEL: .long L{{.*}}-_osrinline
80; CHECK-NEXT: .short 0
81; CHECK-NEXT: .short 2
82; CHECK-NEXT: .byte 1
83; CHECK-NEXT: .byte 8
84; CHECK-NEXT: .short {{[0-9]+}}
85; CHECK-NEXT: .long 0
86; CHECK-NEXT: .byte 1
87; CHECK-NEXT: .byte 8
88; CHECK-NEXT: .short {{[0-9]+}}
89; CHECK-NEXT: .long 0
90define void @osrinline(i64 %a, i64 %b) {
91entry:
92 ; Runtime void->void call.
93 call void inttoptr (i64 244837814094590 to void ()*)()
94 ; Followed by inline OSR patchpoint with 12-byte shadow and 2 live vars.
95 call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 3, i32 12, i64 %a, i64 %b)
96 ret void
97}
98
99; Cold OSR Exit
100;
101; 2 live variables in register.
102;
103; CHECK-LABEL: .long L{{.*}}-_osrcold
104; CHECK-NEXT: .short 0
105; CHECK-NEXT: .short 2
106; CHECK-NEXT: .byte 1
107; CHECK-NEXT: .byte 8
108; CHECK-NEXT: .short {{[0-9]+}}
109; CHECK-NEXT: .long 0
110; CHECK-NEXT: .byte 1
111; CHECK-NEXT: .byte 8
112; CHECK-NEXT: .short {{[0-9]+}}
113; CHECK-NEXT: .long 0
114define void @osrcold(i64 %a, i64 %b) {
115entry:
116 %test = icmp slt i64 %a, %b
117 br i1 %test, label %ret, label %cold
118cold:
119 ; OSR patchpoint with 12-byte nop-slide and 2 live vars.
120 %thunk = inttoptr i64 244837814094590 to i8*
121 call void (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.void(i64 4, i32 20, i8* %thunk, i32 0, i64 %a, i64 %b)
122 unreachable
123ret:
124 ret void
125}
126
127; Property Read
128; CHECK-LABEL: .long L{{.*}}-_propertyRead
129; CHECK-NEXT: .short 0
130; CHECK-NEXT: .short 0
131;
132; FIXME: There are currently no stackmap entries. After moving to
133; AnyRegCC, we will have entries for the object and return value.
134define i64 @propertyRead(i64* %obj) {
135entry:
136 %resolveRead = inttoptr i64 244837814094590 to i8*
137 %result = call i64 (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.i64(i64 5, i32 20, i8* %resolveRead, i32 1, i64* %obj)
138 %add = add i64 %result, 3
139 ret i64 %add
140}
141
142; Property Write
143; CHECK-LABEL: .long L{{.*}}-_propertyWrite
144; CHECK-NEXT: .short 0
145; CHECK-NEXT: .short 2
146; CHECK-NEXT: .byte 1
147; CHECK-NEXT: .byte 8
148; CHECK-NEXT: .short {{[0-9]+}}
149; CHECK-NEXT: .long 0
150; CHECK-NEXT: .byte 1
151; CHECK-NEXT: .byte 8
152; CHECK-NEXT: .short {{[0-9]+}}
153; CHECK-NEXT: .long 0
154define void @propertyWrite(i64 %dummy1, i64* %obj, i64 %dummy2, i64 %a) {
155entry:
156 %resolveWrite = inttoptr i64 244837814094590 to i8*
157 call anyregcc void (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.void(i64 6, i32 20, i8* %resolveWrite, i32 2, i64* %obj, i64 %a)
158 ret void
159}
160
161; Void JS Call
162;
163; 2 live variables in registers.
164;
165; CHECK-LABEL: .long L{{.*}}-_jsVoidCall
166; CHECK-NEXT: .short 0
167; CHECK-NEXT: .short 2
168; CHECK-NEXT: .byte 1
169; CHECK-NEXT: .byte 8
170; CHECK-NEXT: .short {{[0-9]+}}
171; CHECK-NEXT: .long 0
172; CHECK-NEXT: .byte 1
173; CHECK-NEXT: .byte 8
174; CHECK-NEXT: .short {{[0-9]+}}
175; CHECK-NEXT: .long 0
176define void @jsVoidCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) {
177entry:
178 %resolveCall = inttoptr i64 244837814094590 to i8*
179 call void (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.void(i64 7, i32 20, i8* %resolveCall, i32 2, i64* %obj, i64 %arg, i64 %l1, i64 %l2)
180 ret void
181}
182
183; i64 JS Call
184;
185; 2 live variables in registers.
186;
187; CHECK-LABEL: .long L{{.*}}-_jsIntCall
188; CHECK-NEXT: .short 0
189; CHECK-NEXT: .short 2
190; CHECK-NEXT: .byte 1
191; CHECK-NEXT: .byte 8
192; CHECK-NEXT: .short {{[0-9]+}}
193; CHECK-NEXT: .long 0
194; CHECK-NEXT: .byte 1
195; CHECK-NEXT: .byte 8
196; CHECK-NEXT: .short {{[0-9]+}}
197; CHECK-NEXT: .long 0
198define i64 @jsIntCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) {
199entry:
200 %resolveCall = inttoptr i64 244837814094590 to i8*
201 %result = call i64 (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.i64(i64 8, i32 20, i8* %resolveCall, i32 2, i64* %obj, i64 %arg, i64 %l1, i64 %l2)
202 %add = add i64 %result, 3
203 ret i64 %add
204}
205
206; Spilled stack map values.
207;
208; Verify 28 stack map entries.
209;
210; CHECK-LABEL: .long L{{.*}}-_spilledValue
211; CHECK-NEXT: .short 0
212; CHECK-NEXT: .short 28
213;
214; Check that at least one is a spilled entry from RBP.
215; Location: Indirect FP + ...
216; CHECK: .byte 3
217; CHECK-NEXT: .byte 8
218; CHECK-NEXT: .short 29
219define 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) {
220entry:
221 call void (i64, i32, i8*, i32, ...)* @llvm.experimental.patchpoint.void(i64 11, i32 20, i8* 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)
222 ret void
223}
224
225; Spilled stack map values.
226;
227; Verify 23 stack map entries.
228;
229; CHECK-LABEL: .long L{{.*}}-_spilledStackMapValue
230; CHECK-NEXT: .short 0
231; CHECK-NEXT: .short 30
232;
233; Check that at least one is a spilled entry from RBP.
234; Location: Indirect FP + ...
235; CHECK: .byte 3
236; CHECK-NEXT: .byte 8
237; CHECK-NEXT: .short 29
238define webkit_jscc void @spilledStackMapValue(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, i64 %l28, i64 %l29) {
239entry:
240 call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 12, i32 16, 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, i64 %l28, i64 %l29)
241 ret void
242}
243
244
245; Map a constant value.
246;
247; CHECK-LABEL: .long L{{.*}}-_liveConstant
248; CHECK-NEXT: .short 0
249; 1 location
250; CHECK-NEXT: .short 1
251; Loc 0: SmallConstant
252; CHECK-NEXT: .byte 4
253; CHECK-NEXT: .byte 8
254; CHECK-NEXT: .short 0
255; CHECK-NEXT: .long 33
256
257define void @liveConstant() {
258 tail call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 15, i32 8, i32 33)
259 ret void
260}
261
262; Map a value when LR is the only free register.
263;
264; CHECK-LABEL: .long L{{.*}}-_clobberLR
265; CHECK-NEXT: .short 0
266; 1 location
267; CHECK-NEXT: .short 1
268; Loc 0: Indirect FP (r29) - offset
269; CHECK-NEXT: .byte 3
270; CHECK-NEXT: .byte 4
271; CHECK-NEXT: .short 29
272; CHECK-NEXT: .long -{{[0-9]+}}
273define void @clobberLR(i32 %a) {
274 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
275 tail call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 16, i32 8, i32 %a)
276 ret void
277}
278
279declare void @llvm.experimental.stackmap(i64, i32, ...)
280declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)
281declare i64 @llvm.experimental.patchpoint.i64(i64, i32, i8*, i32, ...)