source: icGREP/icgrep-devel/llvm-3.8.0.src/test/CodeGen/AArch64/arm64-abi_align.ll @ 5027

Last change on this file since 5027 was 5027, checked in by cameron, 3 years ago

Upgrade to llvm 3.8

File size: 20.3 KB
Line 
1; RUN: llc < %s -march=arm64 -mcpu=cyclone -enable-misched=false | FileCheck %s
2; RUN: llc < %s -O0 | FileCheck -check-prefix=FAST %s
3target triple = "arm64-apple-darwin"
4
5; rdar://12648441
6; Generated from arm64-arguments.c with -O2.
7; Test passing structs with size < 8, < 16 and > 16
8; with alignment of 16 and without
9
10; Structs with size < 8
11%struct.s38 = type { i32, i16 }
12; With alignment of 16, the size will be padded to multiple of 16 bytes.
13%struct.s39 = type { i32, i16, [10 x i8] }
14; Structs with size < 16
15%struct.s40 = type { i32, i16, i32, i16 }
16%struct.s41 = type { i32, i16, i32, i16 }
17; Structs with size > 16
18%struct.s42 = type { i32, i16, i32, i16, i32, i16 }
19%struct.s43 = type { i32, i16, i32, i16, i32, i16, [10 x i8] }
20
21@g38 = common global %struct.s38 zeroinitializer, align 4
22@g38_2 = common global %struct.s38 zeroinitializer, align 4
23@g39 = common global %struct.s39 zeroinitializer, align 16
24@g39_2 = common global %struct.s39 zeroinitializer, align 16
25@g40 = common global %struct.s40 zeroinitializer, align 4
26@g40_2 = common global %struct.s40 zeroinitializer, align 4
27@g41 = common global %struct.s41 zeroinitializer, align 16
28@g41_2 = common global %struct.s41 zeroinitializer, align 16
29@g42 = common global %struct.s42 zeroinitializer, align 4
30@g42_2 = common global %struct.s42 zeroinitializer, align 4
31@g43 = common global %struct.s43 zeroinitializer, align 16
32@g43_2 = common global %struct.s43 zeroinitializer, align 16
33
34; structs with size < 8 bytes, passed via i64 in x1 and x2
35define i32 @f38(i32 %i, i64 %s1.coerce, i64 %s2.coerce) #0 {
36entry:
37; CHECK-LABEL: f38
38; CHECK: add w[[A:[0-9]+]], w1, w0
39; CHECK: add {{w[0-9]+}}, w[[A]], w2
40  %s1.sroa.0.0.extract.trunc = trunc i64 %s1.coerce to i32
41  %s1.sroa.1.4.extract.shift = lshr i64 %s1.coerce, 32
42  %s2.sroa.0.0.extract.trunc = trunc i64 %s2.coerce to i32
43  %s2.sroa.1.4.extract.shift = lshr i64 %s2.coerce, 32
44  %sext8 = shl nuw nsw i64 %s1.sroa.1.4.extract.shift, 16
45  %sext = trunc i64 %sext8 to i32
46  %conv = ashr exact i32 %sext, 16
47  %sext1011 = shl nuw nsw i64 %s2.sroa.1.4.extract.shift, 16
48  %sext10 = trunc i64 %sext1011 to i32
49  %conv6 = ashr exact i32 %sext10, 16
50  %add = add i32 %s1.sroa.0.0.extract.trunc, %i
51  %add3 = add i32 %add, %s2.sroa.0.0.extract.trunc
52  %add4 = add i32 %add3, %conv
53  %add7 = add i32 %add4, %conv6
54  ret i32 %add7
55}
56
57define i32 @caller38() #1 {
58entry:
59; CHECK-LABEL: caller38
60; CHECK: ldr x1,
61; CHECK: ldr x2,
62  %0 = load i64, i64* bitcast (%struct.s38* @g38 to i64*), align 4
63  %1 = load i64, i64* bitcast (%struct.s38* @g38_2 to i64*), align 4
64  %call = tail call i32 @f38(i32 3, i64 %0, i64 %1) #5
65  ret i32 %call
66}
67
68declare i32 @f38_stack(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6,
69                i32 %i7, i32 %i8, i32 %i9, i64 %s1.coerce, i64 %s2.coerce) #0
70
71; structs with size < 8 bytes, passed on stack at [sp+8] and [sp+16]
72; i9 at [sp]
73define i32 @caller38_stack() #1 {
74entry:
75; CHECK-LABEL: caller38_stack
76; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #8]
77; CHECK: movz w[[C:[0-9]+]], #0x9
78; CHECK: str w[[C]], [sp]
79  %0 = load i64, i64* bitcast (%struct.s38* @g38 to i64*), align 4
80  %1 = load i64, i64* bitcast (%struct.s38* @g38_2 to i64*), align 4
81  %call = tail call i32 @f38_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6,
82                                   i32 7, i32 8, i32 9, i64 %0, i64 %1) #5
83  ret i32 %call
84}
85
86; structs with size < 8 bytes, alignment of 16
87; passed via i128 in x1 and x3
88define i32 @f39(i32 %i, i128 %s1.coerce, i128 %s2.coerce) #0 {
89entry:
90; CHECK-LABEL: f39
91; CHECK: add w[[A:[0-9]+]], w1, w0
92; CHECK: add {{w[0-9]+}}, w[[A]], w3
93  %s1.sroa.0.0.extract.trunc = trunc i128 %s1.coerce to i32
94  %s1.sroa.1.4.extract.shift = lshr i128 %s1.coerce, 32
95  %s2.sroa.0.0.extract.trunc = trunc i128 %s2.coerce to i32
96  %s2.sroa.1.4.extract.shift = lshr i128 %s2.coerce, 32
97  %sext8 = shl nuw nsw i128 %s1.sroa.1.4.extract.shift, 16
98  %sext = trunc i128 %sext8 to i32
99  %conv = ashr exact i32 %sext, 16
100  %sext1011 = shl nuw nsw i128 %s2.sroa.1.4.extract.shift, 16
101  %sext10 = trunc i128 %sext1011 to i32
102  %conv6 = ashr exact i32 %sext10, 16
103  %add = add i32 %s1.sroa.0.0.extract.trunc, %i
104  %add3 = add i32 %add, %s2.sroa.0.0.extract.trunc
105  %add4 = add i32 %add3, %conv
106  %add7 = add i32 %add4, %conv6
107  ret i32 %add7
108}
109
110define i32 @caller39() #1 {
111entry:
112; CHECK-LABEL: caller39
113; CHECK: ldp x1, x2,
114; CHECK: ldp x3, x4,
115  %0 = load i128, i128* bitcast (%struct.s39* @g39 to i128*), align 16
116  %1 = load i128, i128* bitcast (%struct.s39* @g39_2 to i128*), align 16
117  %call = tail call i32 @f39(i32 3, i128 %0, i128 %1) #5
118  ret i32 %call
119}
120
121declare i32 @f39_stack(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6,
122                i32 %i7, i32 %i8, i32 %i9, i128 %s1.coerce, i128 %s2.coerce) #0
123
124; structs with size < 8 bytes, alignment 16
125; passed on stack at [sp+16] and [sp+32]
126define i32 @caller39_stack() #1 {
127entry:
128; CHECK-LABEL: caller39_stack
129; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #32]
130; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16]
131; CHECK: movz w[[C:[0-9]+]], #0x9
132; CHECK: str w[[C]], [sp]
133  %0 = load i128, i128* bitcast (%struct.s39* @g39 to i128*), align 16
134  %1 = load i128, i128* bitcast (%struct.s39* @g39_2 to i128*), align 16
135  %call = tail call i32 @f39_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6,
136                                   i32 7, i32 8, i32 9, i128 %0, i128 %1) #5
137  ret i32 %call
138}
139
140; structs with size < 16 bytes
141; passed via i128 in x1 and x3
142define i32 @f40(i32 %i, [2 x i64] %s1.coerce, [2 x i64] %s2.coerce) #0 {
143entry:
144; CHECK-LABEL: f40
145; CHECK: add w[[A:[0-9]+]], w1, w0
146; CHECK: add {{w[0-9]+}}, w[[A]], w3
147  %s1.coerce.fca.0.extract = extractvalue [2 x i64] %s1.coerce, 0
148  %s2.coerce.fca.0.extract = extractvalue [2 x i64] %s2.coerce, 0
149  %s1.sroa.0.0.extract.trunc = trunc i64 %s1.coerce.fca.0.extract to i32
150  %s2.sroa.0.0.extract.trunc = trunc i64 %s2.coerce.fca.0.extract to i32
151  %s1.sroa.0.4.extract.shift = lshr i64 %s1.coerce.fca.0.extract, 32
152  %sext8 = shl nuw nsw i64 %s1.sroa.0.4.extract.shift, 16
153  %sext = trunc i64 %sext8 to i32
154  %conv = ashr exact i32 %sext, 16
155  %s2.sroa.0.4.extract.shift = lshr i64 %s2.coerce.fca.0.extract, 32
156  %sext1011 = shl nuw nsw i64 %s2.sroa.0.4.extract.shift, 16
157  %sext10 = trunc i64 %sext1011 to i32
158  %conv6 = ashr exact i32 %sext10, 16
159  %add = add i32 %s1.sroa.0.0.extract.trunc, %i
160  %add3 = add i32 %add, %s2.sroa.0.0.extract.trunc
161  %add4 = add i32 %add3, %conv
162  %add7 = add i32 %add4, %conv6
163  ret i32 %add7
164}
165
166define i32 @caller40() #1 {
167entry:
168; CHECK-LABEL: caller40
169; CHECK: ldp x1, x2,
170; CHECK: ldp x3, x4,
171  %0 = load [2 x i64], [2 x i64]* bitcast (%struct.s40* @g40 to [2 x i64]*), align 4
172  %1 = load [2 x i64], [2 x i64]* bitcast (%struct.s40* @g40_2 to [2 x i64]*), align 4
173  %call = tail call i32 @f40(i32 3, [2 x i64] %0, [2 x i64] %1) #5
174  ret i32 %call
175}
176
177declare i32 @f40_stack(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6,
178                i32 %i7, i32 %i8, i32 %i9, [2 x i64] %s1.coerce, [2 x i64] %s2.coerce) #0
179
180; structs with size < 16 bytes
181; passed on stack at [sp+8] and [sp+24]
182define i32 @caller40_stack() #1 {
183entry:
184; CHECK-LABEL: caller40_stack
185; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #24]
186; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #8]
187; CHECK: movz w[[C:[0-9]+]], #0x9
188; CHECK: str w[[C]], [sp]
189  %0 = load [2 x i64], [2 x i64]* bitcast (%struct.s40* @g40 to [2 x i64]*), align 4
190  %1 = load [2 x i64], [2 x i64]* bitcast (%struct.s40* @g40_2 to [2 x i64]*), align 4
191  %call = tail call i32 @f40_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6,
192                         i32 7, i32 8, i32 9, [2 x i64] %0, [2 x i64] %1) #5
193  ret i32 %call
194}
195
196; structs with size < 16 bytes, alignment of 16
197; passed via i128 in x1 and x3
198define i32 @f41(i32 %i, i128 %s1.coerce, i128 %s2.coerce) #0 {
199entry:
200; CHECK-LABEL: f41
201; CHECK: add w[[A:[0-9]+]], w1, w0
202; CHECK: add {{w[0-9]+}}, w[[A]], w3
203  %s1.sroa.0.0.extract.trunc = trunc i128 %s1.coerce to i32
204  %s1.sroa.1.4.extract.shift = lshr i128 %s1.coerce, 32
205  %s2.sroa.0.0.extract.trunc = trunc i128 %s2.coerce to i32
206  %s2.sroa.1.4.extract.shift = lshr i128 %s2.coerce, 32
207  %sext8 = shl nuw nsw i128 %s1.sroa.1.4.extract.shift, 16
208  %sext = trunc i128 %sext8 to i32
209  %conv = ashr exact i32 %sext, 16
210  %sext1011 = shl nuw nsw i128 %s2.sroa.1.4.extract.shift, 16
211  %sext10 = trunc i128 %sext1011 to i32
212  %conv6 = ashr exact i32 %sext10, 16
213  %add = add i32 %s1.sroa.0.0.extract.trunc, %i
214  %add3 = add i32 %add, %s2.sroa.0.0.extract.trunc
215  %add4 = add i32 %add3, %conv
216  %add7 = add i32 %add4, %conv6
217  ret i32 %add7
218}
219
220define i32 @caller41() #1 {
221entry:
222; CHECK-LABEL: caller41
223; CHECK: ldp x1, x2,
224; CHECK: ldp x3, x4,
225  %0 = load i128, i128* bitcast (%struct.s41* @g41 to i128*), align 16
226  %1 = load i128, i128* bitcast (%struct.s41* @g41_2 to i128*), align 16
227  %call = tail call i32 @f41(i32 3, i128 %0, i128 %1) #5
228  ret i32 %call
229}
230
231declare i32 @f41_stack(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6,
232                i32 %i7, i32 %i8, i32 %i9, i128 %s1.coerce, i128 %s2.coerce) #0
233
234; structs with size < 16 bytes, alignment of 16
235; passed on stack at [sp+16] and [sp+32]
236define i32 @caller41_stack() #1 {
237entry:
238; CHECK-LABEL: caller41_stack
239; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #32]
240; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp, #16]
241; CHECK: movz w[[C:[0-9]+]], #0x9
242; CHECK: str w[[C]], [sp]
243  %0 = load i128, i128* bitcast (%struct.s41* @g41 to i128*), align 16
244  %1 = load i128, i128* bitcast (%struct.s41* @g41_2 to i128*), align 16
245  %call = tail call i32 @f41_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6,
246                            i32 7, i32 8, i32 9, i128 %0, i128 %1) #5
247  ret i32 %call
248}
249
250; structs with size of 22 bytes, passed indirectly in x1 and x2
251define i32 @f42(i32 %i, %struct.s42* nocapture %s1, %struct.s42* nocapture %s2) #2 {
252entry:
253; CHECK-LABEL: f42
254; CHECK: ldr w[[A:[0-9]+]], [x1]
255; CHECK: ldr w[[B:[0-9]+]], [x2]
256; CHECK: add w[[C:[0-9]+]], w[[A]], w0
257; CHECK: add {{w[0-9]+}}, w[[C]], w[[B]]
258; FAST: f42
259; FAST: ldr w[[A:[0-9]+]], [x1]
260; FAST: ldr w[[B:[0-9]+]], [x2]
261; FAST: add w[[C:[0-9]+]], w[[A]], w0
262; FAST: add {{w[0-9]+}}, w[[C]], w[[B]]
263  %i1 = getelementptr inbounds %struct.s42, %struct.s42* %s1, i64 0, i32 0
264  %0 = load i32, i32* %i1, align 4, !tbaa !0
265  %i2 = getelementptr inbounds %struct.s42, %struct.s42* %s2, i64 0, i32 0
266  %1 = load i32, i32* %i2, align 4, !tbaa !0
267  %s = getelementptr inbounds %struct.s42, %struct.s42* %s1, i64 0, i32 1
268  %2 = load i16, i16* %s, align 2, !tbaa !3
269  %conv = sext i16 %2 to i32
270  %s5 = getelementptr inbounds %struct.s42, %struct.s42* %s2, i64 0, i32 1
271  %3 = load i16, i16* %s5, align 2, !tbaa !3
272  %conv6 = sext i16 %3 to i32
273  %add = add i32 %0, %i
274  %add3 = add i32 %add, %1
275  %add4 = add i32 %add3, %conv
276  %add7 = add i32 %add4, %conv6
277  ret i32 %add7
278}
279
280; For s1, we allocate a 22-byte space, pass its address via x1
281define i32 @caller42() #3 {
282entry:
283; CHECK-LABEL: caller42
284; CHECK: str {{x[0-9]+}}, [sp, #48]
285; CHECK: str {{q[0-9]+}}, [sp, #32]
286; CHECK: str {{x[0-9]+}}, [sp, #16]
287; CHECK: str {{q[0-9]+}}, [sp]
288; CHECK: add x1, sp, #32
289; CHECK: mov x2, sp
290; Space for s1 is allocated at sp+32
291; Space for s2 is allocated at sp
292
293; FAST-LABEL: caller42
294; FAST: sub sp, sp, #96
295; Space for s1 is allocated at fp-24 = sp+72
296; Space for s2 is allocated at sp+48
297; FAST: sub x[[A:[0-9]+]], x29, #24
298; FAST: add x[[A:[0-9]+]], sp, #48
299; Call memcpy with size = 24 (0x18)
300; FAST: orr {{x[0-9]+}}, xzr, #0x18
301  %tmp = alloca %struct.s42, align 4
302  %tmp1 = alloca %struct.s42, align 4
303  %0 = bitcast %struct.s42* %tmp to i8*
304  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.s42* @g42 to i8*), i64 24, i32 4, i1 false), !tbaa.struct !4
305  %1 = bitcast %struct.s42* %tmp1 to i8*
306  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.s42* @g42_2 to i8*), i64 24, i32 4, i1 false), !tbaa.struct !4
307  %call = call i32 @f42(i32 3, %struct.s42* %tmp, %struct.s42* %tmp1) #5
308  ret i32 %call
309}
310
311declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) #4
312
313declare i32 @f42_stack(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6,
314                       i32 %i7, i32 %i8, i32 %i9, %struct.s42* nocapture %s1,
315                       %struct.s42* nocapture %s2) #2
316
317define i32 @caller42_stack() #3 {
318entry:
319; CHECK-LABEL: caller42_stack
320; CHECK: mov x29, sp
321; CHECK: sub sp, sp, #96
322; CHECK: stur {{x[0-9]+}}, [x29, #-16]
323; CHECK: stur {{q[0-9]+}}, [x29, #-32]
324; CHECK: str {{x[0-9]+}}, [sp, #48]
325; CHECK: str {{q[0-9]+}}, [sp, #32]
326; Space for s1 is allocated at x29-32 = sp+64
327; Space for s2 is allocated at sp+32
328; CHECK: add x[[B:[0-9]+]], sp, #32
329; CHECK: str x[[B]], [sp, #16]
330; CHECK: sub x[[A:[0-9]+]], x29, #32
331; Address of s1 is passed on stack at sp+8
332; CHECK: str x[[A]], [sp, #8]
333; CHECK: movz w[[C:[0-9]+]], #0x9
334; CHECK: str w[[C]], [sp]
335
336; FAST-LABEL: caller42_stack
337; Space for s1 is allocated at fp-24
338; Space for s2 is allocated at fp-48
339; FAST: sub x[[A:[0-9]+]], x29, #24
340; FAST: sub x[[B:[0-9]+]], x29, #48
341; Call memcpy with size = 24 (0x18)
342; FAST: orr {{x[0-9]+}}, xzr, #0x18
343; FAST: str {{w[0-9]+}}, [sp]
344; Address of s1 is passed on stack at sp+8
345; FAST: str {{x[0-9]+}}, [sp, #8]
346; FAST: str {{x[0-9]+}}, [sp, #16]
347  %tmp = alloca %struct.s42, align 4
348  %tmp1 = alloca %struct.s42, align 4
349  %0 = bitcast %struct.s42* %tmp to i8*
350  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.s42* @g42 to i8*), i64 24, i32 4, i1 false), !tbaa.struct !4
351  %1 = bitcast %struct.s42* %tmp1 to i8*
352  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.s42* @g42_2 to i8*), i64 24, i32 4, i1 false), !tbaa.struct !4
353  %call = call i32 @f42_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7,
354                       i32 8, i32 9, %struct.s42* %tmp, %struct.s42* %tmp1) #5
355  ret i32 %call
356}
357
358; structs with size of 22 bytes, alignment of 16
359; passed indirectly in x1 and x2
360define i32 @f43(i32 %i, %struct.s43* nocapture %s1, %struct.s43* nocapture %s2) #2 {
361entry:
362; CHECK-LABEL: f43
363; CHECK: ldr w[[A:[0-9]+]], [x1]
364; CHECK: ldr w[[B:[0-9]+]], [x2]
365; CHECK: add w[[C:[0-9]+]], w[[A]], w0
366; CHECK: add {{w[0-9]+}}, w[[C]], w[[B]]
367; FAST-LABEL: f43
368; FAST: ldr w[[A:[0-9]+]], [x1]
369; FAST: ldr w[[B:[0-9]+]], [x2]
370; FAST: add w[[C:[0-9]+]], w[[A]], w0
371; FAST: add {{w[0-9]+}}, w[[C]], w[[B]]
372  %i1 = getelementptr inbounds %struct.s43, %struct.s43* %s1, i64 0, i32 0
373  %0 = load i32, i32* %i1, align 4, !tbaa !0
374  %i2 = getelementptr inbounds %struct.s43, %struct.s43* %s2, i64 0, i32 0
375  %1 = load i32, i32* %i2, align 4, !tbaa !0
376  %s = getelementptr inbounds %struct.s43, %struct.s43* %s1, i64 0, i32 1
377  %2 = load i16, i16* %s, align 2, !tbaa !3
378  %conv = sext i16 %2 to i32
379  %s5 = getelementptr inbounds %struct.s43, %struct.s43* %s2, i64 0, i32 1
380  %3 = load i16, i16* %s5, align 2, !tbaa !3
381  %conv6 = sext i16 %3 to i32
382  %add = add i32 %0, %i
383  %add3 = add i32 %add, %1
384  %add4 = add i32 %add3, %conv
385  %add7 = add i32 %add4, %conv6
386  ret i32 %add7
387}
388
389define i32 @caller43() #3 {
390entry:
391; CHECK-LABEL: caller43
392; CHECK: str {{q[0-9]+}}, [sp, #48]
393; CHECK: str {{q[0-9]+}}, [sp, #32]
394; CHECK: str {{q[0-9]+}}, [sp, #16]
395; CHECK: str {{q[0-9]+}}, [sp]
396; CHECK: add x1, sp, #32
397; CHECK: mov x2, sp
398; Space for s1 is allocated at sp+32
399; Space for s2 is allocated at sp
400
401; FAST-LABEL: caller43
402; FAST: mov x29, sp
403; Space for s1 is allocated at sp+32
404; Space for s2 is allocated at sp
405; FAST: add x1, sp, #32
406; FAST: mov x2, sp
407; FAST: str {{x[0-9]+}}, [sp, #32]
408; FAST: str {{x[0-9]+}}, [sp, #40]
409; FAST: str {{x[0-9]+}}, [sp, #48]
410; FAST: str {{x[0-9]+}}, [sp, #56]
411; FAST: str {{x[0-9]+}}, [sp]
412; FAST: str {{x[0-9]+}}, [sp, #8]
413; FAST: str {{x[0-9]+}}, [sp, #16]
414; FAST: str {{x[0-9]+}}, [sp, #24]
415  %tmp = alloca %struct.s43, align 16
416  %tmp1 = alloca %struct.s43, align 16
417  %0 = bitcast %struct.s43* %tmp to i8*
418  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.s43* @g43 to i8*), i64 32, i32 16, i1 false), !tbaa.struct !4
419  %1 = bitcast %struct.s43* %tmp1 to i8*
420  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.s43* @g43_2 to i8*), i64 32, i32 16, i1 false), !tbaa.struct !4
421  %call = call i32 @f43(i32 3, %struct.s43* %tmp, %struct.s43* %tmp1) #5
422  ret i32 %call
423}
424
425declare i32 @f43_stack(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6,
426                       i32 %i7, i32 %i8, i32 %i9, %struct.s43* nocapture %s1,
427                       %struct.s43* nocapture %s2) #2
428
429define i32 @caller43_stack() #3 {
430entry:
431; CHECK-LABEL: caller43_stack
432; CHECK: mov x29, sp
433; CHECK: sub sp, sp, #96
434; CHECK: stur {{q[0-9]+}}, [x29, #-16]
435; CHECK: stur {{q[0-9]+}}, [x29, #-32]
436; CHECK: str {{q[0-9]+}}, [sp, #48]
437; CHECK: str {{q[0-9]+}}, [sp, #32]
438; Space for s1 is allocated at x29-32 = sp+64
439; Space for s2 is allocated at sp+32
440; CHECK: add x[[B:[0-9]+]], sp, #32
441; CHECK: str x[[B]], [sp, #16]
442; CHECK: sub x[[A:[0-9]+]], x29, #32
443; Address of s1 is passed on stack at sp+8
444; CHECK: str x[[A]], [sp, #8]
445; CHECK: movz w[[C:[0-9]+]], #0x9
446; CHECK: str w[[C]], [sp]
447
448; FAST-LABEL: caller43_stack
449; FAST: sub sp, sp, #96
450; Space for s1 is allocated at fp-32 = sp+64
451; Space for s2 is allocated at sp+32
452; FAST: sub x[[A:[0-9]+]], x29, #32
453; FAST: add x[[B:[0-9]+]], sp, #32
454; FAST: stur {{x[0-9]+}}, [x29, #-32]
455; FAST: stur {{x[0-9]+}}, [x29, #-24]
456; FAST: stur {{x[0-9]+}}, [x29, #-16]
457; FAST: stur {{x[0-9]+}}, [x29, #-8]
458; FAST: str {{x[0-9]+}}, [sp, #32]
459; FAST: str {{x[0-9]+}}, [sp, #40]
460; FAST: str {{x[0-9]+}}, [sp, #48]
461; FAST: str {{x[0-9]+}}, [sp, #56]
462; FAST: str {{w[0-9]+}}, [sp]
463; Address of s1 is passed on stack at sp+8
464; FAST: str {{x[0-9]+}}, [sp, #8]
465; FAST: str {{x[0-9]+}}, [sp, #16]
466  %tmp = alloca %struct.s43, align 16
467  %tmp1 = alloca %struct.s43, align 16
468  %0 = bitcast %struct.s43* %tmp to i8*
469  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.s43* @g43 to i8*), i64 32, i32 16, i1 false), !tbaa.struct !4
470  %1 = bitcast %struct.s43* %tmp1 to i8*
471  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.s43* @g43_2 to i8*), i64 32, i32 16, i1 false), !tbaa.struct !4
472  %call = call i32 @f43_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7,
473                       i32 8, i32 9, %struct.s43* %tmp, %struct.s43* %tmp1) #5
474  ret i32 %call
475}
476
477; rdar://13668927
478; Check that we don't split an i128.
479declare i32 @callee_i128_split(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5,
480                               i32 %i6, i32 %i7, i128 %s1, i32 %i8)
481
482define i32 @i128_split() {
483entry:
484; CHECK-LABEL: i128_split
485; "i128 %0" should be on stack at [sp].
486; "i32 8" should be on stack at [sp, #16].
487; CHECK: str {{w[0-9]+}}, [sp, #16]
488; CHECK: stp {{x[0-9]+}}, {{x[0-9]+}}, [sp]
489; FAST-LABEL: i128_split
490; FAST: sub sp, sp
491; FAST: mov x[[ADDR:[0-9]+]], sp
492; FAST: str {{w[0-9]+}}, [x[[ADDR]], #16]
493; Load/Store opt is disabled with -O0, so the i128 is split.
494; FAST: str {{x[0-9]+}}, [x[[ADDR]], #8]
495; FAST: str {{x[0-9]+}}, [x[[ADDR]]]
496  %0 = load i128, i128* bitcast (%struct.s41* @g41 to i128*), align 16
497  %call = tail call i32 @callee_i128_split(i32 1, i32 2, i32 3, i32 4, i32 5,
498                                           i32 6, i32 7, i128 %0, i32 8) #5
499  ret i32 %call
500}
501
502declare i32 @callee_i64(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5,
503                               i32 %i6, i32 %i7, i64 %s1, i32 %i8)
504
505define i32 @i64_split() {
506entry:
507; CHECK-LABEL: i64_split
508; "i64 %0" should be in register x7.
509; "i32 8" should be on stack at [sp].
510; CHECK: ldr x7, [{{x[0-9]+}}]
511; CHECK: str {{w[0-9]+}}, [sp, #-16]!
512; FAST-LABEL: i64_split
513; FAST: ldr x7, [{{x[0-9]+}}]
514; FAST: mov x[[R0:[0-9]+]], sp
515; FAST: orr w[[R1:[0-9]+]], wzr, #0x8
516; FAST: str w[[R1]], {{\[}}x[[R0]]{{\]}}
517  %0 = load i64, i64* bitcast (%struct.s41* @g41 to i64*), align 16
518  %call = tail call i32 @callee_i64(i32 1, i32 2, i32 3, i32 4, i32 5,
519                                    i32 6, i32 7, i64 %0, i32 8) #5
520  ret i32 %call
521}
522
523attributes #0 = { noinline nounwind readnone "fp-contract-model"="standard" "relocation-model"="pic" "ssp-buffers-size"="8" }
524attributes #1 = { nounwind readonly "fp-contract-model"="standard" "relocation-model"="pic" "ssp-buffers-size"="8" }
525attributes #2 = { noinline nounwind readonly "fp-contract-model"="standard" "relocation-model"="pic" "ssp-buffers-size"="8" }
526attributes #3 = { nounwind "fp-contract-model"="standard" "relocation-model"="pic" "ssp-buffers-size"="8" }
527attributes #4 = { nounwind }
528attributes #5 = { nobuiltin }
529
530!0 = !{!"int", !1}
531!1 = !{!"omnipotent char", !2}
532!2 = !{!"Simple C/C++ TBAA"}
533!3 = !{!"short", !1}
534!4 = !{i64 0, i64 4, !0, i64 4, i64 2, !3, i64 8, i64 4, !0, i64 12, i64 2, !3, i64 16, i64 4, !0, i64 20, i64 2, !3}
Note: See TracBrowser for help on using the repository browser.