Debian Codegraph @

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

raw
1 // { dg-options "-O -fno-optimize-sibling-calls" }
2 // { dg-final { check-function-bodies "**" "" } }
3
4 #pragma GCC target "+sme2"
5
6 void private_zt0();
7 void out_zt0() __arm_out("zt0");
8 void in_zt0() __arm_in("zt0");
9 void inout_zt0() __arm_inout("zt0");
10 void preserves_zt0() __arm_preserves("zt0");
11
12 /*
13 ** test1:
14 ** ret
15 */
16 __arm_new("zt0") void test1()
17 {
18 }
19
20 /*
21 ** test2:
22 ** ldr w0, \[x0\]
23 ** ret
24 */
25 __arm_new("zt0") int test2(int *ptr)
26 {
27 return *ptr;
28 }
29
30 /*
31 ** test3:
32 ** stp [^\n]+
33 ** mov x29, sp
34 ** bl private_zt0
35 ** (
36 ** mov w0, 0
37 ** ldp [^\n]+
38 ** |
39 ** ldp [^\n]+
40 ** mov w0, 0
41 ** )
42 ** ret
43 */
44 __arm_new("zt0") int test3()
45 {
46 private_zt0();
47 return 0;
48 }
49
50 /*
51 ** test4:
52 ** ...
53 ** mrs x0, tpidr2_el0
54 ** cbz x0, [^\n]+
55 ** bl __arm_tpidr2_save
56 ** msr tpidr2_el0, xzr
57 ** zero { zt0 }
58 ** smstart za
59 ** bl in_zt0
60 ** smstop za
61 ** ldp [^\n]+
62 ** ret
63 */
64 __arm_new("zt0") void test4()
65 {
66 in_zt0(); // Uses zeroed contents.
67 }
68
69 /*
70 ** test5:
71 ** ...
72 ** mrs x0, tpidr2_el0
73 ** cbz x0, [^\n]+
74 ** bl __arm_tpidr2_save
75 ** msr tpidr2_el0, xzr
76 ** smstop za
77 ** bl private_zt0
78 ** smstart za
79 ** bl out_zt0
80 ** bl in_zt0
81 ** ...
82 ** smstop za
83 ** bl private_zt0
84 ** ldp [^\n]+
85 ** ret
86 */
87 __arm_new("zt0") void test5()
88 {
89 private_zt0();
90 out_zt0();
91 in_zt0();
92 private_zt0();
93 }
94
95 // Despite the long test, there shouldn't be too much scope for variation
96 // here. The point is both to test correctness and code quality.
97 /*
98 ** test6:
99 ** stp [^\n]+
100 ** mov x29, sp
101 ** mrs x0, tpidr2_el0
102 ** cbz x0, [^\n]+
103 ** bl __arm_tpidr2_save
104 ** msr tpidr2_el0, xzr
105 ** smstart za
106 ** bl out_zt0
107 ** ...
108 ** str zt0, [^\n]+
109 ** smstop za
110 ** bl private_zt0
111 ** smstart za
112 ** ...
113 ** ldr zt0, [^\n]+
114 ** bl in_zt0
115 ** smstop za
116 ** ldp [^\n]+
117 ** ret
118 */
119 __arm_new("zt0") void test6()
120 {
121 out_zt0();
122 private_zt0();
123 in_zt0();
124 }
125
126 // Rely on previous tests for the part leading up to the smstart.
127 /*
128 ** test7:
129 ** ...
130 ** smstart za
131 ** bl out_zt0
132 ** bl in_zt0
133 ** ...
134 ** smstop za
135 ** bl private_zt0
136 ** smstart za
137 ** bl out_zt0
138 ** bl in_zt0
139 ** smstop za
140 ** ldp [^\n]+
141 ** ret
142 */
143 __arm_new("zt0") void test7()
144 {
145 out_zt0();
146 in_zt0();
147 private_zt0();
148 out_zt0();
149 in_zt0();
150 }
151
152 /*
153 ** test8:
154 ** ...
155 ** smstart za
156 ** bl out_zt0
157 ** bl in_zt0
158 ** ...
159 ** smstop za
160 ** bl private_zt0
161 ** smstart za
162 ** bl out_zt0
163 ** bl in_zt0
164 ** ...
165 ** smstop za
166 ** bl private_zt0
167 ** ldp [^\n]+
168 ** ret
169 */
170 __arm_new("zt0") void test8()
171 {
172 out_zt0();
173 in_zt0();
174 private_zt0();
175 out_zt0();
176 in_zt0();
177 private_zt0();
178 }
179
180 /*
181 ** test9:
182 ** ...
183 ** str zt0, [^\n]+
184 ** smstop za
185 ** bl private_zt0
186 ** bl private_zt0
187 ** bl private_zt0
188 ** bl private_zt0
189 ** smstart za
190 ** ...
191 ** ldr zt0, [^\n]+
192 ** bl in_zt0
193 ** smstop za
194 ** ...
195 */
196 __arm_new("zt0") void test9()
197 {
198 out_zt0();
199 private_zt0();
200 private_zt0();
201 private_zt0();
202 private_zt0();
203 in_zt0();
204 }
205
206 /*
207 ** test10:
208 ** ldr (w[0-9]+), \[x0\]
209 ** cbz \1, [^\n]+
210 ** ldr [^\n]+
211 ** add [^\n]+
212 ** str [^\n]+
213 ** ret
214 ** ...
215 */
216 __arm_new("zt0") void test10(volatile int *ptr)
217 {
218 if (__builtin_expect (*ptr != 0, 1))
219 *ptr = *ptr + 1;
220 else
221 inout_zt0();
222 }
223
224 /*
225 ** test11:
226 ** ...
227 ** ldr w[0-9]+, [^\n]+
228 ** add (w[0-9]+), [^\n]+
229 ** str \1, [^\n]+
230 ** ...
231 ** ret
232 ** mrs x[0-9]+, tpidr2_el0
233 ** ...
234 ** smstart za
235 ** bl inout_zt0
236 ** ldr (w[0-9]+), [^\n]+
237 ** cbnz \2, [^\n]+
238 ** smstop za
239 ** ...
240 */
241 __arm_new("zt0") void test11(volatile int *ptr)
242 {
243 if (__builtin_expect (*ptr == 0, 0))
244 do
245 inout_zt0();
246 while (*ptr);
247 else
248 *ptr += 1;
249 }
250
251 __arm_new("zt0") void test12(volatile int *ptr)
252 {
253 do
254 {
255 inout_zt0();
256 private_zt0();
257 }
258 while (*ptr);
259 out_zt0();
260 in_zt0();
261 }