Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sme2/acle-asm/stnt1_s64_x4.c

raw
1 /* { dg-final { check-function-bodies "**" "" "-DCHECK_ASM" { target { ! ilp32 } } } } */
2
3 #include "test_sme2_acle.h"
4
5 /*
6 ** stnt1_s64_base:
7 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
8 ** ret
9 */
10 TEST_STORE_COUNT (stnt1_s64_base, svint64x4_t, int64_t,
11 svstnt1_s64_x4 (pn8, x0, z0),
12 svstnt1 (pn8, x0, z0))
13
14 /*
15 ** stnt1_s64_index:
16 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, x1, lsl #?3\]
17 ** ret
18 */
19 TEST_STORE_COUNT (stnt1_s64_index, svint64x4_t, int64_t,
20 svstnt1_s64_x4 (pn8, x0 + x1, z0),
21 svstnt1 (pn8, x0 + x1, z0))
22
23 /* Moving the constant into a register would also be OK. */
24 /*
25 ** stnt1_s64_1:
26 ** incb x0
27 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
28 ** ret
29 */
30 TEST_STORE_COUNT (stnt1_s64_1, svint64x4_t, int64_t,
31 svstnt1_s64_x4 (pn8, x0 + svcntd (), z0),
32 svstnt1 (pn8, x0 + svcntd (), z0))
33
34 /* Moving the constant into a register would also be OK. */
35 /*
36 ** stnt1_s64_2:
37 ** incb x0, all, mul #2
38 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
39 ** ret
40 */
41 TEST_STORE_COUNT (stnt1_s64_2, svint64x4_t, int64_t,
42 svstnt1_s64_x4 (pn8, x0 + svcntd () * 2, z0),
43 svstnt1 (pn8, x0 + svcntd () * 2, z0))
44
45 /* Moving the constant into a register would also be OK. */
46 /*
47 ** stnt1_s64_3:
48 ** incb x0, all, mul #3
49 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
50 ** ret
51 */
52 TEST_STORE_COUNT (stnt1_s64_3, svint64x4_t, int64_t,
53 svstnt1_s64_x4 (pn8, x0 + svcntd () * 3, z0),
54 svstnt1 (pn8, x0 + svcntd () * 3, z0))
55
56 /*
57 ** stnt1_s64_4:
58 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #4, mul vl\]
59 ** ret
60 */
61 TEST_STORE_COUNT (stnt1_s64_4, svint64x4_t, int64_t,
62 svstnt1_s64_x4 (pn8, x0 + svcntd () * 4, z0),
63 svstnt1 (pn8, x0 + svcntd () * 4, z0))
64
65 /*
66 ** stnt1_s64_28:
67 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #28, mul vl\]
68 ** ret
69 */
70 TEST_STORE_COUNT (stnt1_s64_28, svint64x4_t, int64_t,
71 svstnt1_s64_x4 (pn8, x0 + svcntd () * 28, z0),
72 svstnt1 (pn8, x0 + svcntd () * 28, z0))
73
74 /*
75 ** stnt1_s64_32:
76 ** [^{]*
77 ** stnt1d {z0\.d - z3\.d}, pn8, \[x[0-9]+\]
78 ** ret
79 */
80 TEST_STORE_COUNT (stnt1_s64_32, svint64x4_t, int64_t,
81 svstnt1_s64_x4 (pn8, x0 + svcntd () * 32, z0),
82 svstnt1 (pn8, x0 + svcntd () * 32, z0))
83
84 /* Moving the constant into a register would also be OK. */
85 /*
86 ** stnt1_s64_m1:
87 ** decb x0
88 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
89 ** ret
90 */
91 TEST_STORE_COUNT (stnt1_s64_m1, svint64x4_t, int64_t,
92 svstnt1_s64_x4 (pn8, x0 - svcntd (), z0),
93 svstnt1 (pn8, x0 - svcntd (), z0))
94
95 /* Moving the constant into a register would also be OK. */
96 /*
97 ** stnt1_s64_m2:
98 ** decb x0, all, mul #2
99 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
100 ** ret
101 */
102 TEST_STORE_COUNT (stnt1_s64_m2, svint64x4_t, int64_t,
103 svstnt1_s64_x4 (pn8, x0 - svcntd () * 2, z0),
104 svstnt1 (pn8, x0 - svcntd () * 2, z0))
105
106 /* Moving the constant into a register would also be OK. */
107 /*
108 ** stnt1_s64_m3:
109 ** decb x0, all, mul #3
110 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
111 ** ret
112 */
113 TEST_STORE_COUNT (stnt1_s64_m3, svint64x4_t, int64_t,
114 svstnt1_s64_x4 (pn8, x0 - svcntd () * 3, z0),
115 svstnt1 (pn8, x0 - svcntd () * 3, z0))
116
117 /*
118 ** stnt1_s64_m4:
119 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #-4, mul vl\]
120 ** ret
121 */
122 TEST_STORE_COUNT (stnt1_s64_m4, svint64x4_t, int64_t,
123 svstnt1_s64_x4 (pn8, x0 - svcntd () * 4, z0),
124 svstnt1 (pn8, x0 - svcntd () * 4, z0))
125
126 /*
127 ** stnt1_s64_m32:
128 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #-32, mul vl\]
129 ** ret
130 */
131 TEST_STORE_COUNT (stnt1_s64_m32, svint64x4_t, int64_t,
132 svstnt1_s64_x4 (pn8, x0 - svcntd () * 32, z0),
133 svstnt1 (pn8, x0 - svcntd () * 32, z0))
134
135 /*
136 ** stnt1_s64_m36:
137 ** [^{]*
138 ** stnt1d {z0\.d - z3\.d}, pn8, \[x[0-9]+\]
139 ** ret
140 */
141 TEST_STORE_COUNT (stnt1_s64_m36, svint64x4_t, int64_t,
142 svstnt1_s64_x4 (pn8, x0 - svcntd () * 36, z0),
143 svstnt1 (pn8, x0 - svcntd () * 36, z0))
144
145 /*
146 ** stnt1_s64_z17:
147 ** mov [^\n]+
148 ** mov [^\n]+
149 ** mov [^\n]+
150 ** mov [^\n]+
151 ** stnt1d {z[^\n]+}, pn8, \[x0\]
152 ** ret
153 */
154 TEST_STORE_COUNT (stnt1_s64_z17, svint64x4_t, int64_t,
155 svstnt1_s64_x4 (pn8, x0, z17),
156 svstnt1 (pn8, x0, z17))
157
158 /*
159 ** stnt1_s64_z22:
160 ** mov [^\n]+
161 ** mov [^\n]+
162 ** mov [^\n]+
163 ** mov [^\n]+
164 ** stnt1d {z[^\n]+}, pn8, \[x0\]
165 ** ret
166 */
167 TEST_STORE_COUNT (stnt1_s64_z22, svint64x4_t, int64_t,
168 svstnt1_s64_x4 (pn8, x0, z22),
169 svstnt1 (pn8, x0, z22))
170
171 /*
172 ** stnt1_s64_z28:
173 ** stnt1d {z28\.d - z31\.d}, pn8, \[x0\]
174 ** ret
175 */
176 TEST_STORE_COUNT (stnt1_s64_z28, svint64x4_t, int64_t,
177 svstnt1_s64_x4 (pn8, x0, z28),
178 svstnt1 (pn8, x0, z28))
179
180 /*
181 ** stnt1_s64_pn0:
182 ** mov p([89]|1[0-5])\.b, p0\.b
183 ** stnt1d {z0\.d - z3\.d}, pn\1, \[x0\]
184 ** ret
185 */
186 TEST_STORE_COUNT (stnt1_s64_pn0, svint64x4_t, int64_t,
187 svstnt1_s64_x4 (pn0, x0, z0),
188 svstnt1 (pn0, x0, z0))
189
190 /*
191 ** stnt1_s64_pn7:
192 ** mov p([89]|1[0-5])\.b, p7\.b
193 ** stnt1d {z0\.d - z3\.d}, pn\1, \[x0\]
194 ** ret
195 */
196 TEST_STORE_COUNT (stnt1_s64_pn7, svint64x4_t, int64_t,
197 svstnt1_s64_x4 (pn7, x0, z0),
198 svstnt1 (pn7, x0, z0))
199
200 /*
201 ** stnt1_s64_pn15:
202 ** stnt1d {z0\.d - z3\.d}, pn15, \[x0\]
203 ** ret
204 */
205 TEST_STORE_COUNT (stnt1_s64_pn15, svint64x4_t, int64_t,
206 svstnt1_s64_x4 (pn15, x0, z0),
207 svstnt1 (pn15, x0, z0))
208
209 /*
210 ** stnt1_vnum_s64_0:
211 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
212 ** ret
213 */
214 TEST_STORE_COUNT (stnt1_vnum_s64_0, svint64x4_t, int64_t,
215 svstnt1_vnum_s64_x4 (pn8, x0, 0, z0),
216 svstnt1_vnum (pn8, x0, 0, z0))
217
218 /* Moving the constant into a register would also be OK. */
219 /*
220 ** stnt1_vnum_s64_1:
221 ** incb x0
222 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
223 ** ret
224 */
225 TEST_STORE_COUNT (stnt1_vnum_s64_1, svint64x4_t, int64_t,
226 svstnt1_vnum_s64_x4 (pn8, x0, 1, z0),
227 svstnt1_vnum (pn8, x0, 1, z0))
228
229 /* Moving the constant into a register would also be OK. */
230 /*
231 ** stnt1_vnum_s64_2:
232 ** incb x0, all, mul #2
233 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
234 ** ret
235 */
236 TEST_STORE_COUNT (stnt1_vnum_s64_2, svint64x4_t, int64_t,
237 svstnt1_vnum_s64_x4 (pn8, x0, 2, z0),
238 svstnt1_vnum (pn8, x0, 2, z0))
239
240 /* Moving the constant into a register would also be OK. */
241 /*
242 ** stnt1_vnum_s64_3:
243 ** incb x0, all, mul #3
244 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
245 ** ret
246 */
247 TEST_STORE_COUNT (stnt1_vnum_s64_3, svint64x4_t, int64_t,
248 svstnt1_vnum_s64_x4 (pn8, x0, 3, z0),
249 svstnt1_vnum (pn8, x0, 3, z0))
250
251 /*
252 ** stnt1_vnum_s64_4:
253 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #4, mul vl\]
254 ** ret
255 */
256 TEST_STORE_COUNT (stnt1_vnum_s64_4, svint64x4_t, int64_t,
257 svstnt1_vnum_s64_x4 (pn8, x0, 4, z0),
258 svstnt1_vnum (pn8, x0, 4, z0))
259
260 /*
261 ** stnt1_vnum_s64_28:
262 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #28, mul vl\]
263 ** ret
264 */
265 TEST_STORE_COUNT (stnt1_vnum_s64_28, svint64x4_t, int64_t,
266 svstnt1_vnum_s64_x4 (pn8, x0, 28, z0),
267 svstnt1_vnum (pn8, x0, 28, z0))
268
269 /*
270 ** stnt1_vnum_s64_32:
271 ** [^{]*
272 ** stnt1d {z0\.d - z3\.d}, pn8, \[x[0-9]+\]
273 ** ret
274 */
275 TEST_STORE_COUNT (stnt1_vnum_s64_32, svint64x4_t, int64_t,
276 svstnt1_vnum_s64_x4 (pn8, x0, 32, z0),
277 svstnt1_vnum (pn8, x0, 32, z0))
278
279 /* Moving the constant into a register would also be OK. */
280 /*
281 ** stnt1_vnum_s64_m1:
282 ** decb x0
283 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
284 ** ret
285 */
286 TEST_STORE_COUNT (stnt1_vnum_s64_m1, svint64x4_t, int64_t,
287 svstnt1_vnum_s64_x4 (pn8, x0, -1, z0),
288 svstnt1_vnum (pn8, x0, -1, z0))
289
290 /* Moving the constant into a register would also be OK. */
291 /*
292 ** stnt1_vnum_s64_m2:
293 ** decb x0, all, mul #2
294 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
295 ** ret
296 */
297 TEST_STORE_COUNT (stnt1_vnum_s64_m2, svint64x4_t, int64_t,
298 svstnt1_vnum_s64_x4 (pn8, x0, -2, z0),
299 svstnt1_vnum (pn8, x0, -2, z0))
300
301 /* Moving the constant into a register would also be OK. */
302 /*
303 ** stnt1_vnum_s64_m3:
304 ** decb x0, all, mul #3
305 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0\]
306 ** ret
307 */
308 TEST_STORE_COUNT (stnt1_vnum_s64_m3, svint64x4_t, int64_t,
309 svstnt1_vnum_s64_x4 (pn8, x0, -3, z0),
310 svstnt1_vnum (pn8, x0, -3, z0))
311
312 /*
313 ** stnt1_vnum_s64_m4:
314 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #-4, mul vl\]
315 ** ret
316 */
317 TEST_STORE_COUNT (stnt1_vnum_s64_m4, svint64x4_t, int64_t,
318 svstnt1_vnum_s64_x4 (pn8, x0, -4, z0),
319 svstnt1_vnum (pn8, x0, -4, z0))
320
321 /*
322 ** stnt1_vnum_s64_m32:
323 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, #-32, mul vl\]
324 ** ret
325 */
326 TEST_STORE_COUNT (stnt1_vnum_s64_m32, svint64x4_t, int64_t,
327 svstnt1_vnum_s64_x4 (pn8, x0, -32, z0),
328 svstnt1_vnum (pn8, x0, -32, z0))
329
330 /*
331 ** stnt1_vnum_s64_m36:
332 ** [^{]*
333 ** stnt1d {z0\.d - z3\.d}, pn8, \[x[0-9]+\]
334 ** ret
335 */
336 TEST_STORE_COUNT (stnt1_vnum_s64_m36, svint64x4_t, int64_t,
337 svstnt1_vnum_s64_x4 (pn8, x0, -36, z0),
338 svstnt1_vnum (pn8, x0, -36, z0))
339
340 /*
341 ** stnt1_vnum_s64_x1:
342 ** cntb (x[0-9]+)
343 ** (
344 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
345 ** stnt1d {z0\.d - z3\.d}, pn8, \[\2\]
346 ** |
347 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
348 ** stnt1d {z0\.d - z3\.d}, pn8, \[x0, \3\]
349 ** )
350 ** ret
351 */
352 TEST_STORE_COUNT (stnt1_vnum_s64_x1, svint64x4_t, int64_t,
353 svstnt1_vnum_s64_x4 (pn8, x0, x1, z0),
354 svstnt1_vnum (pn8, x0, x1, z0))