1 /* { dg-do compile } */
2 /* { dg-options "-O -fshrink-wrap -fstack-clash-protection -g" } */
3 /* { dg-final { check-function-bodies "**" "" } } */
4
5 #pragma GCC aarch64 "arm_sve.h"
6
7 svbool_t take_stack_args (volatile void *, void *, int, int, int,
8 int, int, int, int);
9
10 /*
11 ** test_1:
12 ** cntb x12
13 ** add x12, x12, #?16
14 ** mov x11, sp
15 ** ...
16 ** sub sp, sp, x12
17 ** str p4, \[sp\]
18 ** ...
19 ** ptrue p0\.b, all
20 ** ldr p4, \[sp\]
21 ** addvl sp, sp, #1
22 ** add sp, sp, #?16
23 ** ret
24 */
25 svbool_t
26 test_1 (void)
27 {
28 volatile int x = 1;
29 asm volatile ("" ::: "p4");
30 return svptrue_b8 ();
31 }
32
33 /*
34 ** test_2:
35 ** stp x24, x25, \[sp, -48\]!
36 ** str x26, \[sp, 16\]
37 ** cntb x13
38 ** mov x11, sp
39 ** ...
40 ** sub sp, sp, x13
41 ** str p4, \[sp\]
42 ** ...
43 ** ptrue p0\.b, all
44 ** ldr p4, \[sp\]
45 ** addvl sp, sp, #1
46 ** ldr x26, \[sp, 16\]
47 ** ldp x24, x25, \[sp\], 48
48 ** ret
49 */
50 svbool_t
51 test_2 (void)
52 {
53 volatile int x = 1;
54 asm volatile ("" ::: "p4", "x24", "x25", "x26");
55 return svptrue_b8 ();
56 }
57
58 /*
59 ** test_3:
60 ** cntb x12
61 ** mov x13, #?4128
62 ** add x12, x12, x13
63 ** mov x11, sp
64 ** ...
65 ** sub sp, sp, x12
66 ** addvl x11, sp, #1
67 ** stp x24, x25, \[x11\]
68 ** str x26, \[x11, 16\]
69 ** str p4, \[sp\]
70 ** ...
71 ** ptrue p0\.b, all
72 ** ldr p4, \[sp\]
73 ** addvl sp, sp, #1
74 ** ldp x24, x25, \[sp\]
75 ** ldr x26, \[sp, 16\]
76 ** mov x12, #?4128
77 ** add sp, sp, x12
78 ** ret
79 */
80 svbool_t
81 test_3 (void)
82 {
83 volatile int x[1024];
84 asm volatile ("" :: "r" (x) : "p4", "x24", "x25", "x26");
85 return svptrue_b8 ();
86 }
87
88 /*
89 ** test_4:
90 ** cntb x12, all, mul #2
91 ** mov x11, sp
92 ** ...
93 ** sub sp, sp, x12
94 ** str p4, \[sp\]
95 ** ...
96 ** ptrue p0\.h, all
97 ** ldr p4, \[sp\]
98 ** addvl sp, sp, #2
99 ** ret
100 */
101 svbool_t
102 test_4 (void)
103 {
104 volatile svint32_t b;
105 b = svdup_s32 (1);
106 asm volatile ("" ::: "p4");
107 return svptrue_b16 ();
108 }
109
110 /*
111 ** test_5:
112 ** cntb x12, all, mul #2
113 ** add x12, x12, #?32
114 ** mov x11, sp
115 ** ...
116 ** sub sp, sp, x12
117 ** addvl x11, sp, #1
118 ** stp x24, x25, \[x11\]
119 ** str x26, \[x11, 16\]
120 ** str p4, \[sp\]
121 ** ...
122 ** ptrue p0\.h, all
123 ** ldr p4, \[sp\]
124 ** addvl sp, sp, #1
125 ** ldp x24, x25, \[sp\]
126 ** ldr x26, \[sp, 16\]
127 ** addvl sp, sp, #1
128 ** add sp, sp, #?32
129 ** ret
130 */
131 svbool_t
132 test_5 (void)
133 {
134 volatile svint32_t b;
135 b = svdup_s32 (1);
136 asm volatile ("" ::: "p4", "x24", "x25", "x26");
137 return svptrue_b16 ();
138 }
139
140 /*
141 ** test_6:
142 ** stp x29, x30, \[sp, -16\]!
143 ** mov x29, sp
144 ** cntb x13
145 ** mov x11, sp
146 ** ...
147 ** sub sp, sp, x13
148 ** str p4, \[sp\]
149 ** sub sp, sp, #?16
150 ** ...
151 ** ptrue p0\.b, all
152 ** add sp, sp, #?16
153 ** ldr p4, \[sp\]
154 ** addvl sp, sp, #1
155 ** ldp x29, x30, \[sp\], 16
156 ** ret
157 */
158 svbool_t
159 test_6 (void)
160 {
161 take_stack_args (0, 0, 1, 2, 3, 4, 5, 6, 7);
162 asm volatile ("" ::: "p4");
163 return svptrue_b8 ();
164 }
165
166 /*
167 ** test_7:
168 ** cntb x12
169 ** mov x13, #?4112
170 ** add x12, x12, x13
171 ** mov x11, sp
172 ** ...
173 ** sub sp, sp, x12
174 ** addvl x11, sp, #1
175 ** stp x29, x30, \[x11\]
176 ** addvl x29, sp, #1
177 ** str p4, \[sp\]
178 ** sub sp, sp, #?16
179 ** ...
180 ** ptrue p0\.b, all
181 ** add sp, sp, #?16
182 ** ldr p4, \[sp\]
183 ** addvl sp, sp, #1
184 ** ldp x29, x30, \[sp\]
185 ** mov x12, #?4112
186 ** add sp, sp, x12
187 ** ret
188 */
189 svbool_t
190 test_7 (void)
191 {
192 volatile int x[1024];
193 take_stack_args (x, 0, 1, 2, 3, 4, 5, 6, 7);
194 asm volatile ("" ::: "p4");
195 return svptrue_b8 ();
196 }
197
198 /*
199 ** test_8:
200 ** cntb x12
201 ** mov x13, #?4144
202 ** add x12, x12, x13
203 ** mov x11, sp
204 ** ...
205 ** sub sp, sp, x12
206 ** addvl x11, sp, #1
207 ** stp x29, x30, \[x11\]
208 ** addvl x29, sp, #1
209 ** stp x24, x25, \[x29, 16\]
210 ** str x26, \[x29, 32\]
211 ** str p4, \[sp\]
212 ** sub sp, sp, #?16
213 ** ...
214 ** ptrue p0\.b, all
215 ** add sp, sp, #?16
216 ** ldr p4, \[sp\]
217 ** addvl sp, sp, #1
218 ** ldp x24, x25, \[sp, 16\]
219 ** ldr x26, \[sp, 32\]
220 ** ldp x29, x30, \[sp\]
221 ** mov x12, #?4144
222 ** add sp, sp, x12
223 ** ret
224 */
225 svbool_t
226 test_8 (void)
227 {
228 volatile int x[1024];
229 take_stack_args (x, 0, 1, 2, 3, 4, 5, 6, 7);
230 asm volatile ("" ::: "p4", "x24", "x25", "x26");
231 return svptrue_b8 ();
232 }
233
234 /*
235 ** test_9:
236 ** cntb x12
237 ** mov x13, #?4112
238 ** add x12, x12, x13
239 ** mov x11, sp
240 ** ...
241 ** sub sp, sp, x12
242 ** addvl x11, sp, #1
243 ** stp x29, x30, \[x11\]
244 ** addvl x29, sp, #1
245 ** str p4, \[sp\]
246 ** sub sp, sp, #?16
247 ** ...
248 ** ptrue p0\.b, all
249 ** addvl sp, x29, #-1
250 ** ldr p4, \[sp\]
251 ** addvl sp, sp, #1
252 ** ldp x29, x30, \[sp\]
253 ** mov x12, #?4112
254 ** add sp, sp, x12
255 ** ret
256 */
257 svbool_t
258 test_9 (int n)
259 {
260 volatile int x[1024];
261 take_stack_args (x, __builtin_alloca (n), 1, 2, 3, 4, 5, 6, 7);
262 asm volatile ("" ::: "p4");
263 return svptrue_b8 ();
264 }
265
266 /*
267 ** test_10:
268 ** cntb x12
269 ** mov x13, #?4144
270 ** add x12, x12, x13
271 ** mov x11, sp
272 ** ...
273 ** sub sp, sp, x12
274 ** addvl x11, sp, #1
275 ** stp x29, x30, \[x11\]
276 ** addvl x29, sp, #1
277 ** stp x24, x25, \[x29, 16\]
278 ** str x26, \[x29, 32\]
279 ** str p4, \[sp\]
280 ** sub sp, sp, #?16
281 ** ...
282 ** ptrue p0\.b, all
283 ** addvl sp, x29, #-1
284 ** ldr p4, \[sp\]
285 ** addvl sp, sp, #1
286 ** ldp x24, x25, \[sp, 16\]
287 ** ldr x26, \[sp, 32\]
288 ** ldp x29, x30, \[sp\]
289 ** mov x12, #?4144
290 ** add sp, sp, x12
291 ** ret
292 */
293 svbool_t
294 test_10 (int n)
295 {
296 volatile int x[1024];
297 take_stack_args (x, __builtin_alloca (n), 1, 2, 3, 4, 5, 6, 7);
298 asm volatile ("" ::: "p4", "x24", "x25", "x26");
299 return svptrue_b8 ();
300 }
301
302 /*
303 ** test_11:
304 ** cntb x12
305 ** add x12, x12, #?3008
306 ** add x12, x12, #?126976
307 ** mov x11, sp
308 ** ...
309 ** sub sp, sp, x12
310 ** addvl x11, sp, #1
311 ** stp x29, x30, \[x11\]
312 ** addvl x29, sp, #1
313 ** stp x24, x25, \[x29, 16\]
314 ** str x26, \[x29, 32\]
315 ** str p4, \[sp\]
316 ** sub sp, sp, #?16
317 ** ...
318 ** ptrue p0\.b, all
319 ** addvl sp, x29, #-1
320 ** ldr p4, \[sp\]
321 ** addvl sp, sp, #1
322 ** ldp x24, x25, \[sp, 16\]
323 ** ldr x26, \[sp, 32\]
324 ** ldp x29, x30, \[sp\]
325 ** add sp, sp, #?3008
326 ** add sp, sp, #?126976
327 ** ret
328 */
329 svbool_t
330 test_11 (int n)
331 {
332 volatile int x[0x7ee4];
333 take_stack_args (x, __builtin_alloca (n), 1, 2, 3, 4, 5, 6, 7);
334 asm volatile ("" ::: "p4", "x24", "x25", "x26");
335 return svptrue_b8 ();
336 }