Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sme/za_state_4.c

raw
1 // { dg-options "-O -fno-optimize-sibling-calls -fno-stack-clash-protection" }
2 // { dg-final { check-function-bodies "**" "" } }
3
4 void private_za();
5 void out_za() __arm_out("za");
6 void in_za() __arm_in("za");
7 void inout_za() __arm_inout("za");
8 void preserves_za() __arm_preserves("za");
9
10 /*
11 ** test1:
12 ** ret
13 */
14 __arm_new("za") void test1()
15 {
16 }
17
18 /*
19 ** test2:
20 ** ldr w0, \[x0\]
21 ** ret
22 */
23 __arm_new("za") int test2(int *ptr)
24 {
25 return *ptr;
26 }
27
28 /*
29 ** test3:
30 ** stp [^\n]+
31 ** mov x29, sp
32 ** bl private_za
33 ** (
34 ** mov w0, 0
35 ** ldp [^\n]+
36 ** |
37 ** ldp [^\n]+
38 ** mov w0, 0
39 ** )
40 ** ret
41 */
42 __arm_new("za") int test3()
43 {
44 private_za();
45 return 0;
46 }
47
48 /*
49 ** test4:
50 ** ...
51 ** mrs x0, tpidr2_el0
52 ** cbz x0, [^\n]+
53 ** bl __arm_tpidr2_save
54 ** msr tpidr2_el0, xzr
55 ** zero { za }
56 ** smstart za
57 ** bl in_za
58 ** smstop za
59 ** ldp [^\n]+
60 ** ret
61 */
62 __arm_new("za") void test4()
63 {
64 in_za(); // Uses zeroed contents.
65 }
66
67 /*
68 ** test5:
69 ** ...
70 ** mrs x0, tpidr2_el0
71 ** cbz x0, [^\n]+
72 ** bl __arm_tpidr2_save
73 ** msr tpidr2_el0, xzr
74 ** smstop za
75 ** bl private_za
76 ** smstart za
77 ** bl out_za
78 ** bl in_za
79 ** smstop za
80 ** bl private_za
81 ** ldp [^\n]+
82 ** ret
83 */
84 __arm_new("za") void test5()
85 {
86 private_za();
87 out_za();
88 in_za();
89 private_za();
90 }
91
92 // Despite the long test, there shouldn't be too much scope for variation
93 // here. The point is both to test correctness and code quality.
94 /*
95 ** test6:
96 ** stp [^\n]+
97 ** mov x29, sp
98 ** mrs x0, tpidr2_el0
99 ** cbz x0, [^\n]+
100 ** bl __arm_tpidr2_save
101 ** msr tpidr2_el0, xzr
102 ** smstart za
103 ** bl out_za
104 ** rdsvl (x[0-9]+), #1
105 ** mul (x[0-9]+), \1, \1
106 ** sub sp, sp, \2
107 ** mov (x[0-9]+), sp
108 ** stp \3, \1, \[x29, #?16\]
109 ** add (x[0-9]+), x29, #?16
110 ** msr tpidr2_el0, \4
111 ** bl private_za
112 ** (
113 ** add (x[0-9]+), x29, #?16
114 ** mrs (x[0-9]+), tpidr2_el0
115 ** cbnz \6, [^\n]+
116 ** smstart za
117 ** mov x0, \5
118 ** |
119 ** add x0, x29, #?16
120 ** mrs (x[0-9]+), tpidr2_el0
121 ** cbnz \6, [^\n]+
122 ** smstart za
123 ** )
124 ** bl __arm_tpidr2_restore
125 ** msr tpidr2_el0, xzr
126 ** bl in_za
127 ** smstop za
128 ** mov sp, x29
129 ** ldp [^\n]+
130 ** ret
131 */
132 __arm_new("za") void test6()
133 {
134 out_za();
135 private_za();
136 in_za();
137 }
138
139 // Rely on previous tests for the part leading up to the smstart.
140 /*
141 ** test7:
142 ** ...
143 ** smstart za
144 ** bl out_za
145 ** bl in_za
146 ** smstop za
147 ** bl private_za
148 ** smstart za
149 ** bl out_za
150 ** bl in_za
151 ** smstop za
152 ** ldp [^\n]+
153 ** ret
154 */
155 __arm_new("za") void test7()
156 {
157 out_za();
158 in_za();
159 private_za();
160 out_za();
161 in_za();
162 }
163
164 /*
165 ** test8:
166 ** ...
167 ** smstart za
168 ** bl out_za
169 ** bl in_za
170 ** smstop za
171 ** bl private_za
172 ** smstart za
173 ** bl out_za
174 ** bl in_za
175 ** smstop za
176 ** bl private_za
177 ** ldp [^\n]+
178 ** ret
179 */
180 __arm_new("za") void test8()
181 {
182 out_za();
183 in_za();
184 private_za();
185 out_za();
186 in_za();
187 private_za();
188 }
189
190 /*
191 ** test9:
192 ** ...
193 ** msr tpidr2_el0, x[0-9]+
194 ** bl private_za
195 ** bl private_za
196 ** bl private_za
197 ** bl private_za
198 ** add x[0-9]+, x29, #?16
199 ** mrs x[0-9]+, tpidr2_el0
200 ** ...
201 */
202 __arm_new("za") void test9()
203 {
204 out_za();
205 private_za();
206 private_za();
207 private_za();
208 private_za();
209 in_za();
210 }
211
212 /*
213 ** test10:
214 ** ldr (w[0-9]+), \[x0\]
215 ** cbz \1, [^\n]+
216 ** ldr [^\n]+
217 ** add [^\n]+
218 ** str [^\n]+
219 ** ret
220 ** ...
221 */
222 __arm_new("za") void test10(volatile int *ptr)
223 {
224 if (__builtin_expect (*ptr != 0, 1))
225 *ptr = *ptr + 1;
226 else
227 inout_za();
228 }
229
230 /*
231 ** test11:
232 ** ...
233 ** ldr w[0-9]+, [^\n]+
234 ** add (w[0-9]+), [^\n]+
235 ** str \1, [^\n]+
236 ** ...
237 ** ret
238 ** mrs x[0-9]+, tpidr2_el0
239 ** ...
240 ** smstart za
241 ** bl inout_za
242 ** ldr (w[0-9]+), [^\n]+
243 ** cbnz \2, [^\n]+
244 ** smstop za
245 ** ...
246 */
247 __arm_new("za") void test11(volatile int *ptr)
248 {
249 if (__builtin_expect (*ptr == 0, 0))
250 do
251 inout_za();
252 while (*ptr);
253 else
254 *ptr += 1;
255 }
256
257 __arm_new("za") void test12(volatile int *ptr)
258 {
259 do
260 {
261 inout_za();
262 private_za();
263 }
264 while (*ptr);
265 out_za();
266 in_za();
267 }
268
269 /*
270 ** test13:
271 ** stp [^\n]+
272 ** ...
273 ** stp [^\n]+
274 ** ...
275 ** bl __arm_tpidr2_save
276 ** ...
277 ** msr tpidr2_el0, x[0-9]+
278 ** bl private_za
279 ** ...
280 ** mrs x[0-9]+, tpidr2_el0
281 ** ...
282 ** bl inout_za
283 ** ...
284 ** msr tpidr2_el0, x[0-9]+
285 ** ...
286 ** bl private_za
287 ** ...
288 ** cbnz [^\n]+
289 ** smstart za
290 ** msr tpidr2_el0, xzr
291 ** bl out_za
292 ** bl in_za
293 ** ...
294 ** smstop za
295 ** ...
296 */
297 __arm_new("za") void test13(volatile int *ptr)
298 {
299 do
300 {
301 private_za();
302 inout_za();
303 private_za();
304 }
305 while (*ptr);
306 out_za();
307 in_za();
308 }
309
310 /*
311 ** test14:
312 ** ...
313 ** bl __arm_tpidr2_save
314 ** ...
315 ** smstart za
316 ** bl inout_za
317 ** ldr [^\n]+
318 ** cbnz [^\n]+
319 ** bl out_za
320 ** bl in_za
321 ** smstop za
322 ** ...
323 */
324 __arm_new("za") void test14(volatile int *ptr)
325 {
326 do
327 inout_za();
328 while (*ptr);
329 out_za();
330 in_za();
331 }
332
333 /*
334 ** test15:
335 ** ...
336 ** bl __arm_tpidr2_save
337 ** ...
338 ** smstart za
339 ** bl out_za
340 ** bl in_za
341 ** ldr [^\n]+
342 ** cbnz [^\n]+
343 ** smstop za
344 ** bl private_za
345 ** ldr [^\n]+
346 ** ldp [^\n]+
347 ** ret
348 */
349 __arm_new("za") void test15(volatile int *ptr)
350 {
351 do
352 {
353 out_za();
354 in_za();
355 }
356 while (*ptr);
357 private_za();
358 }
359
360 /*
361 ** test16:
362 ** ...
363 ** bl __arm_tpidr2_save
364 ** ...
365 ** smstart za
366 ** b [^\n]+
367 -- loop:
368 ** ...
369 ** mrs x[0-9]+, tpidr2_el0
370 ** ...
371 ** msr tpidr2_el0, xzr
372 -- loop_entry:
373 ** bl inout_za
374 ** ...
375 ** msr tpidr2_el0, x[0-9]+
376 ** bl private_za
377 ** ldr [^\n]+
378 ** cbnz [^\n]+
379 ** msr tpidr2_el0, xzr
380 ** smstop za
381 ** bl private_za
382 ** ...
383 */
384 __arm_new("za") void test16(volatile int *ptr)
385 {
386 do
387 {
388 inout_za();
389 private_za();
390 }
391 while (*ptr);
392 private_za();
393 }
394
395 /*
396 ** test17:
397 ** ...
398 ** bl private_za
399 ** ldr [^\n]+
400 ** cbnz [^\n]+
401 ** ...
402 ** msr tpidr2_el0, xzr
403 ** ...
404 ** smstop za
405 ** ...
406 */
407 __arm_new("za") void test17(volatile int *ptr)
408 {
409 do
410 {
411 inout_za();
412 private_za();
413 }
414 while (*ptr);
415 }
416
417 /*
418 ** test18:
419 ** ldr w[0-9]+, [^\n]+
420 ** cbnz w[0-9]+, [^\n]+
421 ** ret
422 ** ...
423 ** smstop za
424 ** bl private_za
425 ** ...
426 */
427 __arm_new("za") void test18(volatile int *ptr)
428 {
429 if (__builtin_expect (*ptr, 0))
430 {
431 out_za();
432 in_za();
433 private_za();
434 }
435 }
436
437 /*
438 ** test19:
439 ** ...
440 ** ldr w[0-9]+, [^\n]+
441 ** cbz w[0-9]+, [^\n]+
442 ** mrs x[0-9]+, tpidr2_el0
443 ** ...
444 ** smstop za
445 ** bl private_za
446 ** ...
447 */
448 __arm_new("za") void test19(volatile int *ptr)
449 {
450 if (__builtin_expect (*ptr != 0, 1))
451 private_za();
452 else
453 do
454 {
455 inout_za();
456 private_za();
457 }
458 while (*ptr);
459 }
460
461 /*
462 ** test20:
463 ** ...
464 ** bl a20
465 ** (?:(?!x0).)*
466 ** bl b20
467 ** ...
468 ** mov ([wx][0-9]+), [wx]0
469 ** ...
470 ** bl __arm_tpidr2_restore
471 ** ...
472 ** mov [wx]0, \1
473 ** ...
474 ** bl c20
475 ** ...
476 */
477 __arm_new("za") void test20()
478 {
479 extern int a20() __arm_inout("za");
480 extern int b20(int);
481 extern void c20(int) __arm_inout("za");
482 c20(b20(a20()));
483 }
484
485 /*
486 ** test21:
487 ** ...
488 ** bl a21
489 ** (?:(?!x0).)*
490 ** bl b21
491 ** ...
492 ** mov (x[0-9]+), x0
493 ** ...
494 ** bl __arm_tpidr2_restore
495 ** ...
496 ** mov x0, \1
497 ** ...
498 ** bl c21
499 ** ...
500 */
501 __arm_new("za") void test21()
502 {
503 extern __UINT64_TYPE__ a21() __arm_inout("za");
504 extern __UINT64_TYPE__ b21(__UINT64_TYPE__);
505 extern void c21(__UINT64_TYPE__) __arm_inout("za");
506 c21(b21(a21()));
507 }
508
509 /*
510 ** test22:
511 ** (?:(?!rdsvl).)*
512 ** rdsvl x[0-9]+, #1
513 ** (?:(?!rdsvl).)*
514 */
515 __arm_new("za") void test22(volatile int *ptr)
516 {
517 inout_za();
518 if (*ptr)
519 *ptr += 1;
520 else
521 private_za();
522 private_za();
523 in_za();
524 }
525
526 /*
527 ** test23:
528 ** (?:(?!__arm_tpidr2_save).)*
529 ** bl __arm_tpidr2_save
530 ** (?:(?!__arm_tpidr2_save).)*
531 */
532 __arm_new("za") void test23(volatile int *ptr)
533 {
534 if (*ptr)
535 *ptr += 1;
536 else
537 inout_za();
538 inout_za();
539 }
540
541 /*
542 ** test24:
543 ** ...
544 ** bl in_za
545 ** ...
546 ** incb x1
547 ** ...
548 ** bl out_za
549 ** bl inout_za
550 ** ...
551 ** msr tpidr2_el0, x[0-9]+
552 ** ...
553 ** bl private_za
554 ** ...
555 ** mrs x[0-9]+, tpidr2_el0
556 ** ...
557 ** incb x1
558 ** ...
559 ** msr tpidr2_el0, x[0-9]+
560 ** ...
561 ** bl private_za
562 ** ...
563 ** mrs x[0-9]+, tpidr2_el0
564 ** ...
565 ** incb x1
566 ** ...
567 ** smstop za
568 ** ...
569 ** bl private_za
570 ** ...
571 ** ret
572 */
573 __arm_new("za") void test24()
574 {
575 in_za();
576 asm ("incb\tx1" ::: "x1", "za");
577 out_za();
578 inout_za();
579 private_za();
580 asm ("incb\tx1" ::: "x1", "za");
581 private_za();
582 asm ("incb\tx1" ::: "x1", "za");
583 in_za();
584 private_za();
585 }