Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / bb698c7d5f23474930fae702ac44ee5ab8e03781 / . / llvm / test / CodeGen / Mips / dynamic-stack-realignment.ll
blob: 777930a37ad508c69f8421e83abb42dcadeccb42 [file] [log] [blame]
Vasileios Kalintirisbb698c72015-06-02 13:14:46 +0000[diff] [blame^]1; RUN: llc < %s -march=mips -mcpu=mips2 | FileCheck %s \
2; RUN: --check-prefix=ALL --check-prefix=GP32
3; RUN: llc < %s -march=mips -mcpu=mips32 | FileCheck %s \
4; RUN: --check-prefix=ALL --check-prefix=GP32
5; RUN: llc < %s -march=mips -mcpu=mips32r6 | FileCheck %s \
6; RUN: --check-prefix=ALL --check-prefix=GP32
7; RUN: llc < %s -march=mips64 -mcpu=mips3 | FileCheck %s \
8; RUN: --check-prefix=ALL --check-prefix=GP64 -check-prefix=N64
9; RUN: llc < %s -march=mips64 -mcpu=mips64 | FileCheck %s \
10; RUN: --check-prefix=ALL --check-prefix=GP64 -check-prefix=N64
11; RUN: llc < %s -march=mips64 -mcpu=mips64r6 | FileCheck %s \
12; RUN: --check-prefix=ALL --check-prefix=GP64 -check-prefix=N64
13; RUN: llc < %s -march=mips64 -mcpu=mips3 -target-abi n32 | FileCheck %s \
14; RUN: --check-prefix=ALL --check-prefix=GP64 -check-prefix=N32
15; RUN: llc < %s -march=mips64 -mcpu=mips64 -target-abi n32 | FileCheck %s \
16; RUN: --check-prefix=ALL --check-prefix=GP64 -check-prefix=N32
17; RUN: llc < %s -march=mips64 -mcpu=mips64r6 -target-abi n32 | FileCheck %s \
18; RUN: --check-prefix=ALL --check-prefix=GP64 -check-prefix=N32
19
20; Check dynamic stack realignment in functions without variable-sized objects.
21
22declare void @helper_01(i32, i32, i32, i32, i32*)
23
24; O32 ABI
25define void @func_01() {
26entry:
27; GP32-LABEL: func_01:
28
29 ; prologue
30 ; FIXME: We are currently over-allocating stack space. This particular case
31 ; needs a frame of up to between 16 and 512-bytes but currently
32 ; allocates between 1024 and 1536 bytes
33 ; GP32: addiu $sp, $sp, -1024
34 ; GP32: sw $ra, 1020($sp)
35 ; GP32: sw $fp, 1016($sp)
36 ;
37 ; GP32: move $fp, $sp
38 ; GP32: addiu $[[T0:[0-9]+|ra|gp]], $zero, -512
39 ; GP32-NEXT: and $sp, $sp, $[[T0]]
40
41 ; body
42 ; GP32: addiu $[[T1:[0-9]+]], $sp, 512
43 ; GP32: sw $[[T1]], 16($sp)
44
45 ; epilogue
46 ; GP32: move $sp, $fp
47 ; GP32: lw $fp, 1016($sp)
48 ; GP32: lw $ra, 1020($sp)
49 ; GP32: addiu $sp, $sp, 1024
50
51 %a = alloca i32, align 512
52 call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a)
53 ret void
54}
55
56declare void @helper_02(i32, i32, i32, i32,
57 i32, i32, i32, i32, i32*)
58
59; N32/N64 ABIs
60define void @func_02() {
61entry:
62; GP64-LABEL: func_02:
63
64 ; prologue
65 ; FIXME: We are currently over-allocating stack space. This particular case
66 ; needs a frame of up to between 16 and 512-bytes but currently
67 ; allocates between 1024 and 1536 bytes
68 ; N32: addiu $sp, $sp, -1024
69 ; N64: daddiu $sp, $sp, -1024
70 ; GP64: sd $ra, 1016($sp)
71 ; GP64: sd $fp, 1008($sp)
72 ; N32: sd $gp, 1000($sp)
73 ;
74 ; GP64: move $fp, $sp
75 ; N32: addiu $[[T0:[0-9]+|ra]], $zero, -512
76 ; N64: daddiu $[[T0:[0-9]+|ra]], $zero, -512
77 ; GP64-NEXT: and $sp, $sp, $[[T0]]
78
79 ; body
80 ; N32: addiu $[[T1:[0-9]+]], $sp, 512
81 ; N64: daddiu $[[T1:[0-9]+]], $sp, 512
82 ; GP64: sd $[[T1]], 0($sp)
83
84 ; epilogue
85 ; GP64: move $sp, $fp
86 ; N32: ld $gp, 1000($sp)
87 ; GP64: ld $fp, 1008($sp)
88 ; GP64: ld $ra, 1016($sp)
89 ; N32: addiu $sp, $sp, 1024
90 ; N64: daddiu $sp, $sp, 1024
91
92 %a = alloca i32, align 512
93 call void @helper_02(i32 0, i32 0, i32 0, i32 0,
94 i32 0, i32 0, i32 0, i32 0, i32* %a)
95 ret void
96}
97
98; Verify that we use $fp for referencing incoming arguments.
99
100declare void @helper_03(i32, i32, i32, i32, i32*, i32*)
101
102; O32 ABI
103define void @func_03(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32* %b) {
104entry:
105; GP32-LABEL: func_03:
106
107 ; body
108 ; FIXME: We are currently over-allocating stack space.
109 ; GP32-DAG: addiu $[[T0:[0-9]+]], $sp, 512
110 ; GP32-DAG: sw $[[T0]], 16($sp)
111 ; GP32-DAG: lw $[[T1:[0-9]+]], 1040($fp)
112 ; GP32-DAG: sw $[[T1]], 20($sp)
113
114 %a = alloca i32, align 512
115 call void @helper_03(i32 0, i32 0, i32 0, i32 0, i32* %a, i32* %b)
116 ret void
117}
118
119declare void @helper_04(i32, i32, i32, i32,
120 i32, i32, i32, i32, i32*, i32*)
121
122; N32/N64 ABIs
123define void @func_04(i32 %p0, i32 %p1, i32 %p2, i32 %p3,
124 i32 %p4, i32 %p5, i32 %p6, i32 %p7,
125 i32* %b) {
126entry:
127; GP64-LABEL: func_04:
128
129 ; body
130 ; FIXME: We are currently over-allocating stack space.
131 ; N32-DAG: addiu $[[T0:[0-9]+]], $sp, 512
132 ; N64-DAG: daddiu $[[T0:[0-9]+]], $sp, 512
133 ; GP64-DAG: sd $[[T0]], 0($sp)
134 ; GP64-DAG: ld $[[T1:[0-9]+]], 1024($fp)
135 ; GP64-DAG: sd $[[T1]], 8($sp)
136
137 %a = alloca i32, align 512
138 call void @helper_04(i32 0, i32 0, i32 0, i32 0,
139 i32 0, i32 0, i32 0, i32 0, i32* %a, i32* %b)
140 ret void
141}
142
143; Check dynamic stack realignment in functions with variable-sized objects.
144
145; O32 ABI
146define void @func_05(i32 %sz) {
147entry:
148; GP32-LABEL: func_05:
149
150 ; prologue
151 ; FIXME: We are currently over-allocating stack space.
152 ; GP32: addiu $sp, $sp, -1024
153 ; GP32: sw $fp, 1020($sp)
154 ; GP32: sw $23, 1016($sp)
155 ;
156 ; GP32: move $fp, $sp
157 ; GP32: addiu $[[T0:[0-9]+|gp]], $zero, -512
158 ; GP32-NEXT: and $sp, $sp, $[[T0]]
159 ; GP32-NEXT: move $23, $sp
160
161 ; body
162 ; GP32: addiu $[[T1:[0-9]+]], $zero, 222
163 ; GP32: sw $[[T1]], 508($23)
164
165 ; epilogue
166 ; GP32: move $sp, $fp
167 ; GP32: lw $23, 1016($sp)
168 ; GP32: lw $fp, 1020($sp)
169 ; GP32: addiu $sp, $sp, 1024
170
171 %a0 = alloca i32, i32 %sz, align 512
172 %a1 = alloca i32, align 4
173
174 store volatile i32 111, i32* %a0, align 512
175 store volatile i32 222, i32* %a1, align 4
176
177 ret void
178}
179
180; N32/N64 ABIs
181define void @func_06(i32 %sz) {
182entry:
183; GP64-LABEL: func_06:
184
185 ; prologue
186 ; FIXME: We are currently over-allocating stack space.
187 ; N32: addiu $sp, $sp, -1024
188 ; N64: daddiu $sp, $sp, -1024
189 ; GP64: sd $fp, 1016($sp)
190 ; GP64: sd $23, 1008($sp)
191 ;
192 ; GP64: move $fp, $sp
193 ; GP64: addiu $[[T0:[0-9]+|gp]], $zero, -512
194 ; GP64-NEXT: and $sp, $sp, $[[T0]]
195 ; GP64-NEXT: move $23, $sp
196
197 ; body
198 ; GP64: addiu $[[T1:[0-9]+]], $zero, 222
199 ; GP64: sw $[[T1]], 508($23)
200
201 ; epilogue
202 ; GP64: move $sp, $fp
203 ; GP64: ld $23, 1008($sp)
204 ; GP64: ld $fp, 1016($sp)
205 ; N32: addiu $sp, $sp, 1024
206 ; N64: daddiu $sp, $sp, 1024
207
208 %a0 = alloca i32, i32 %sz, align 512
209 %a1 = alloca i32, align 4
210
211 store volatile i32 111, i32* %a0, align 512
212 store volatile i32 222, i32* %a1, align 4
213
214 ret void
215}
216
217; Verify that we use $fp for referencing incoming arguments and $sp for
218; building outbound arguments for nested function calls.
219
220; O32 ABI
221define void @func_07(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %sz) {
222entry:
223; GP32-LABEL: func_07:
224
225 ; body
226 ; FIXME: We are currently over-allocating stack space.
227 ; GP32-DAG: lw $[[T0:[0-9]+]], 1040($fp)
228 ;
229 ; GP32-DAG: addiu $[[T1:[0-9]+]], $zero, 222
230 ; GP32-DAG: sw $[[T1]], 508($23)
231 ;
232 ; GP32-DAG: sw $[[T2:[0-9]+]], 16($sp)
233
234 %a0 = alloca i32, i32 %sz, align 512
235 %a1 = alloca i32, align 4
236
237 store volatile i32 111, i32* %a0, align 512
238 store volatile i32 222, i32* %a1, align 4
239
240 call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a1)
241
242 ret void
243}
244
245; N32/N64 ABIs
246define void @func_08(i32 %p0, i32 %p1, i32 %p2, i32 %p3,
247 i32 %p4, i32 %p5, i32 %p6, i32 %p7,
248 i32 %sz) {
249entry:
250; GP64-LABEL: func_08:
251
252 ; body
253 ; FIXME: We are currently over-allocating stack space.
254 ; N32-DAG: lw $[[T0:[0-9]+]], 1028($fp)
255 ; N64-DAG: lwu $[[T0:[0-9]+]], 1028($fp)
256 ;
257 ; GP64-DAG: addiu $[[T1:[0-9]+]], $zero, 222
258 ; GP64-DAG: sw $[[T1]], 508($23)
259 ;
260 ; GP64-DAG: sd $[[T2:[0-9]+]], 0($sp)
261
262 %a0 = alloca i32, i32 %sz, align 512
263 %a1 = alloca i32, align 4
264
265 store volatile i32 111, i32* %a0, align 512
266 store volatile i32 222, i32* %a1, align 4
267
268 call void @helper_02(i32 0, i32 0, i32 0, i32 0,
269 i32 0, i32 0, i32 0, i32 0, i32* %a1)
270 ret void
271}
272
273; Check that we do not perform dynamic stack realignment in the presence of
274; the "no-realign-stack" function attribute.
275define void @func_09() "no-realign-stack" {
276entry:
277; ALL-LABEL: func_09:
278
279 ; ALL-NOT: and $sp, $sp, $[[T0:[0-9]+|ra|gp]]
280
281 %a = alloca i32, align 512
282 call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a)
283 ret void
284}
285
286define void @func_10(i32 %sz) "no-realign-stack" {
287entry:
288; ALL-LABEL: func_10:
289
290 ; ALL-NOT: and $sp, $sp, $[[T0:[0-9]+|ra|gp]]
291
292 %a0 = alloca i32, i32 %sz, align 512
293 %a1 = alloca i32, align 4
294
295 store volatile i32 111, i32* %a0, align 512
296 store volatile i32 222, i32* %a1, align 4
297
298 ret void
299}