Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve/acle/asm/test_sve_acle.h

raw
1 #ifndef TEST_SVE_ACLE_H
2 #define TEST_SVE_ACLE_H 1
3
4 #include <arm_neon_sve_bridge.h>
5
6 #if defined (TEST_OVERLOADS)
7 #define INVOKE(CODE1, CODE2) CODE2
8 #elif defined (TEST_FULL)
9 #define INVOKE(CODE1, CODE2) CODE1
10 #else
11 #error "Please define -DTEST_OVERLOADS or -DTEST_FULL"
12 #endif
13
14 #ifdef STREAMING_COMPATIBLE
15 #define SM_ATTR __arm_streaming_compatible
16 #elif defined(STREAMING)
17 #define SM_ATTR __arm_streaming
18 #else
19 #define SM_ATTR
20 #endif
21
22 #ifdef SHARED_ZA
23 #define ZA_ATTR __arm_inout("za")
24 #else
25 #define ZA_ATTR
26 #endif
27
28 #ifdef SHARED_ZT0
29 #define ZT0_ATTR __arm_inout("zt0")
30 #else
31 #define ZT0_ATTR
32 #endif
33
34 #define ATTR SM_ATTR ZA_ATTR ZT0_ATTR
35
36 #ifdef __cplusplus
37 #define PROTO(NAME, RET, ARGS) \
38 extern "C" RET NAME ARGS ATTR; RET NAME ARGS ATTR
39 #else
40 #define PROTO(NAME, RET, ARGS) RET NAME ARGS ATTR
41 #endif
42
43 #define TEST_UNIFORM_Z(NAME, TYPE, CODE1, CODE2) \
44 PROTO (NAME, TYPE, (TYPE z0, TYPE z1, TYPE z2, TYPE z3, \
45 svbool_t p0, svbool_t p1)) \
46 { \
47 INVOKE (CODE1, CODE2); \
48 return z0; \
49 }
50
51 #define TEST_UNIFORM_P(NAME, CODE1, CODE2) \
52 PROTO (NAME, svbool_t, (svbool_t p0, svbool_t p1, \
53 svbool_t p2, svbool_t p3)) \
54 { \
55 INVOKE (CODE1, CODE2); \
56 return p0; \
57 }
58
59 #define TEST_UNIFORM_P_SINGLE(NAME, CODE) \
60 PROTO (NAME, svbool_t, (svbool_t p0, svbool_t p1, \
61 svbool_t p2, svbool_t p3)) \
62 { \
63 CODE; \
64 return p0; \
65 }
66
67 #define TEST_UNIFORM_S(NAME, TYPE, CODE1, CODE2) \
68 PROTO (NAME, TYPE, (TYPE x0, TYPE x1, TYPE x2, TYPE x3, \
69 svbool_t p0, svbool_t p1)) \
70 { \
71 INVOKE (CODE1, CODE2); \
72 return x0; \
73 }
74
75 #define TEST_DUAL_Z(NAME, TYPE1, TYPE2, CODE1, CODE2) \
76 PROTO (NAME, TYPE1, (TYPE1 z0, TYPE1 z1, TYPE1 z2, TYPE1 z3, \
77 TYPE2 z4, TYPE2 z5, TYPE2 z6, TYPE2 z7, \
78 svbool_t p0, svbool_t p1, fpm_t fpm0)) \
79 { \
80 INVOKE (CODE1, CODE2); \
81 return z0; \
82 }
83
84 #define TEST_DUAL_Z_REV(NAME, TYPE1, TYPE2, CODE1, CODE2) \
85 PROTO (NAME, TYPE1, (TYPE2 z0, TYPE2 z1, TYPE2 z2, TYPE2 z3, \
86 TYPE1 z4, TYPE1 z5, TYPE1 z6, TYPE1 z7, \
87 svbool_t p0, svbool_t p1, fpm_t fpm0)) \
88 { \
89 TYPE1 z0_res; \
90 INVOKE (CODE1, CODE2); \
91 return z0_res; \
92 }
93
94 #define TEST_DUAL_P(NAME, TYPE1, TYPE2, CODE1, CODE2) \
95 PROTO (NAME, TYPE1, (TYPE1 p0, TYPE1 p1, TYPE2 p2, TYPE2 p3)) \
96 { \
97 INVOKE (CODE1, CODE2); \
98 return p0; \
99 }
100
101 #define TEST_DUAL_P_REV(NAME, TYPE1, TYPE2, CODE1, CODE2) \
102 PROTO (NAME, TYPE1, (TYPE2 p0, TYPE2 p1, TYPE1 p2, TYPE1 p3)) \
103 { \
104 TYPE1 p0_res; \
105 INVOKE (CODE1, CODE2); \
106 return p0_res; \
107 }
108
109 #define TEST_TRIPLE_Z(NAME, TYPE1, TYPE2, TYPE3, CODE1, CODE2) \
110 PROTO (NAME, TYPE1, (TYPE1 z0, TYPE1 z1, TYPE2 z2, TYPE2 z3, \
111 TYPE3 z4, TYPE3 z5, \
112 svbool_t p0, svbool_t p1)) \
113 { \
114 INVOKE (CODE1, CODE2); \
115 return z0; \
116 }
117
118 #define TEST_TRIPLE_Z_REV2(NAME, TYPE1, TYPE2, TYPE3, CODE1, CODE2)\
119 PROTO (NAME, TYPE1, (TYPE2 z0, TYPE2 z1, TYPE1 z2, TYPE1 z3, \
120 TYPE3 z4, TYPE3 z5, \
121 svbool_t p0, svbool_t p1)) \
122 { \
123 TYPE1 z0_res; \
124 INVOKE (CODE1, CODE2); \
125 return z0_res; \
126 }
127
128 #define TEST_TRIPLE_Z_REV(NAME, TYPE1, TYPE2, TYPE3, CODE1, CODE2)\
129 PROTO (NAME, TYPE1, (TYPE3 z0, TYPE3 z1, TYPE2 z2, TYPE2 z3, \
130 TYPE1 z4, TYPE1 z5, \
131 svbool_t p0, svbool_t p1)) \
132 { \
133 TYPE1 z0_res; \
134 INVOKE (CODE1, CODE2); \
135 return z0_res; \
136 }
137
138 #define TEST_DUAL_LANE_REG(NAME, ZTYPE1, ZTYPE2, REG, CODE1, CODE2) \
139 PROTO (NAME, void, (fpm_t fpm0)) \
140 { \
141 register ZTYPE1 z0 __asm ("z0"); \
142 register ZTYPE2 z1 __asm ("z1"); \
143 register ZTYPE2 REG __asm (#REG); \
144 __asm volatile ("" : "=w" (z0), "=w" (z1), "=w" (REG)); \
145 INVOKE (CODE1, CODE2); \
146 __asm volatile ("" :: "w" (z0)); \
147 }
148
149 #define TEST_TRIPLE_LANE_REG(NAME, ZTYPE1, ZTYPE2, ZTYPE3, REG, CODE1, CODE2) \
150 PROTO (NAME, void, (void)) \
151 { \
152 register ZTYPE1 z0 __asm ("z0"); \
153 register ZTYPE2 z1 __asm ("z1"); \
154 register ZTYPE3 REG __asm (#REG); \
155 __asm volatile ("" : "=w" (z0), "=w" (z1), "=w" (REG)); \
156 INVOKE (CODE1, CODE2); \
157 __asm volatile ("" :: "w" (z0)); \
158 }
159
160 #define TEST_TYPE_CHANGE_Z(NAME, TYPE1, TYPE2, CODE1, CODE2) \
161 PROTO (NAME, TYPE1, (TYPE2 z0, TYPE2 z1, TYPE2 z2, TYPE2 z3, \
162 svbool_t p0, svbool_t p1)) \
163 { \
164 TYPE1 z0_res; \
165 INVOKE (CODE1, CODE2); \
166 return z0_res; \
167 }
168
169 #define TEST_UNIFORM_ZX(NAME, ZTYPE, STYPE, CODE1, CODE2) \
170 PROTO (NAME, ZTYPE, (ZTYPE z0, ZTYPE z1, ZTYPE z2, ZTYPE z3, \
171 svbool_t p0, STYPE x0)) \
172 { \
173 INVOKE (CODE1, CODE2); \
174 return z0; \
175 }
176
177 #define TEST_UNIFORM_ZD(NAME, ZTYPE, STYPE, CODE1, CODE2) \
178 PROTO (NAME, ZTYPE, (ZTYPE z0, ZTYPE z1, ZTYPE z2, ZTYPE z3, \
179 svbool_t p0, STYPE d4)) \
180 { \
181 INVOKE (CODE1, CODE2); \
182 return z0; \
183 }
184
185 #define TEST_UNIFORM_PS(NAME, CODE1, CODE2) \
186 PROTO (NAME, svbool_t, (svbool_t p0, svbool_t p1, \
187 svbool_t p2, svbool_t p3, bool x0)) \
188 { \
189 INVOKE (CODE1, CODE2); \
190 return p0; \
191 }
192
193 #define TEST_DUAL_ZD(NAME, ZTYPE1, ZTYPE2, STYPE, CODE1, CODE2) \
194 PROTO (NAME, ZTYPE1, (ZTYPE1 z0, ZTYPE1 z1, ZTYPE1 z2, \
195 ZTYPE1 z3, ZTYPE2 z4, ZTYPE2 z5, \
196 ZTYPE2 z6, STYPE d7, svbool_t p0, \
197 svbool_t p1, fpm_t fpm0)) \
198 { \
199 INVOKE (CODE1, CODE2); \
200 return z0; \
201 }
202
203 #define TEST_DUAL_ZX(NAME, ZTYPE1, ZTYPE2, STYPE, CODE1, CODE2) \
204 PROTO (NAME, ZTYPE1, (ZTYPE1 z0, ZTYPE1 z1, ZTYPE1 z2, \
205 ZTYPE1 z3, ZTYPE2 z4, ZTYPE2 z5, \
206 ZTYPE2 z6, ZTYPE2 z7, svbool_t p0, \
207 svbool_t p1, STYPE x0)) \
208 { \
209 INVOKE (CODE1, CODE2); \
210 return z0; \
211 }
212
213 #define TEST_TRIPLE_ZX(NAME, TYPE1, TYPE2, TYPE3, CODE1, CODE2) \
214 PROTO (NAME, TYPE1, (TYPE1 z0, TYPE1 z1, TYPE2 z2, TYPE2 z3, \
215 TYPE3 x0, TYPE3 x1, \
216 svbool_t p0, svbool_t p1)) \
217 { \
218 INVOKE (CODE1, CODE2); \
219 return z0; \
220 }
221
222 #define TEST_TYPE_CHANGE_ZX(NAME, ZTYPE1, ZTYPE2, STYPE, CODE1, CODE2) \
223 PROTO (NAME, ZTYPE1, (ZTYPE2 z0, ZTYPE2 z1, ZTYPE2 z2, \
224 ZTYPE2 z3, svbool_t p0, svbool_t p1, \
225 STYPE x0)) \
226 { \
227 ZTYPE1 z0_res; \
228 INVOKE (CODE1, CODE2); \
229 return z0_res; \
230 }
231
232 #define TEST_LOAD(NAME, ZTYPE, STYPE, CODE1, CODE2) \
233 PROTO (NAME, ZTYPE, (svbool_t p0, const STYPE *x0, \
234 intptr_t x1)) \
235 { \
236 ZTYPE z0; \
237 INVOKE (CODE1, CODE2); \
238 return z0; \
239 }
240
241 #define TEST_LOAD_COUNT(NAME, TTYPE, STYPE, CODE1, CODE2) \
242 PROTO (NAME, void, (const STYPE *x0, intptr_t x1)) \
243 { \
244 register svcount_t pn0 __asm ("pn0"); \
245 register svcount_t pn7 __asm ("pn7"); \
246 register svcount_t pn8 __asm ("pn8"); \
247 register svcount_t pn15 __asm ("pn15"); \
248 register TTYPE z0 __asm ("z0"); \
249 register TTYPE z17 __asm ("z17"); \
250 register TTYPE z22 __asm ("z22"); \
251 register TTYPE z28 __asm ("z28"); \
252 __asm volatile ("" : "=Upa" (pn0), "=Upa" (pn7), \
253 "=Upa" (pn8), "=Upa" (pn15)); \
254 INVOKE (CODE1, CODE2); \
255 __asm volatile ("" :: "w" (z0), "w" (z17), \
256 "w" (z22), "w" (z28)); \
257 }
258
259 #define TEST_LOAD_GATHER_SZ(NAME, RES_TYPE, STYPE, ZTYPE, CODE1, CODE2) \
260 PROTO (NAME, RES_TYPE, (ZTYPE z0, ZTYPE z1, svbool_t p0, \
261 const STYPE *x0)) \
262 { \
263 RES_TYPE z0_res; \
264 INVOKE (CODE1, CODE2); \
265 return z0_res; \
266 }
267
268 #define TEST_LOAD_GATHER_ZS(NAME, RES_TYPE, ZTYPE, CODE1, CODE2) \
269 PROTO (NAME, RES_TYPE, (ZTYPE z0, ZTYPE z1, svbool_t p0, \
270 int64_t x0)) \
271 { \
272 RES_TYPE z0_res; \
273 INVOKE (CODE1, CODE2); \
274 return z0_res; \
275 }
276
277 #define TEST_PREFETCH(NAME, STYPE, CODE1, CODE2) \
278 PROTO (NAME, void, (svbool_t p0, const STYPE *x0, \
279 intptr_t x1)) \
280 { \
281 INVOKE (CODE1, CODE2); \
282 }
283
284 #define TEST_PREFETCH_GATHER_SZ(NAME, ZTYPE, CODE1, CODE2) \
285 PROTO (NAME, void, (ZTYPE z0, ZTYPE z1, svbool_t p0, \
286 const void *x0)) \
287 { \
288 INVOKE (CODE1, CODE2); \
289 }
290
291 #define TEST_PREFETCH_GATHER_ZS(NAME, ZTYPE, CODE1, CODE2) \
292 PROTO (NAME, void, (ZTYPE z0, ZTYPE z1, svbool_t p0, \
293 int64_t x0)) \
294 { \
295 INVOKE (CODE1, CODE2); \
296 }
297
298 #define TEST_STORE(NAME, ZTYPE, STYPE, CODE1, CODE2) \
299 PROTO (NAME, void, (ZTYPE z0, svbool_t p0, STYPE *x0, \
300 intptr_t x1)) \
301 { \
302 INVOKE (CODE1, CODE2); \
303 }
304
305 #define TEST_STORE_COUNT(NAME, TTYPE, STYPE, CODE1, CODE2) \
306 PROTO (NAME, void, (STYPE *x0, intptr_t x1)) \
307 { \
308 register svcount_t pn0 __asm ("pn0"); \
309 register svcount_t pn7 __asm ("pn7"); \
310 register svcount_t pn8 __asm ("pn8"); \
311 register svcount_t pn15 __asm ("pn15"); \
312 register TTYPE z0 __asm ("z0"); \
313 register TTYPE z17 __asm ("z17"); \
314 register TTYPE z22 __asm ("z22"); \
315 register TTYPE z28 __asm ("z28"); \
316 __asm volatile ("" : "=Upa" (pn0), "=Upa" (pn7), \
317 "=Upa" (pn8), "=Upa" (pn15), \
318 "=w" (z0), "=w" (z17), "=w" (z22), \
319 "=w" (z28)); \
320 INVOKE (CODE1, CODE2); \
321 }
322
323 #define TEST_STORE_SCATTER_SZ(NAME, DATA_TYPE, STYPE, ZTYPE, CODE1, CODE2) \
324 PROTO (NAME, void, (DATA_TYPE z0, ZTYPE z1, svbool_t p0, \
325 STYPE *x0)) \
326 { \
327 INVOKE (CODE1, CODE2); \
328 }
329
330 #define TEST_STORE_SCATTER_ZS(NAME, DATA_TYPE, ZTYPE, CODE1, CODE2) \
331 PROTO (NAME, void, (DATA_TYPE z0, ZTYPE z1, svbool_t p0, \
332 int64_t x0)) \
333 { \
334 INVOKE (CODE1, CODE2); \
335 }
336
337 #define TEST_P(NAME, CODE1, CODE2) \
338 PROTO (NAME, svbool_t, (void)) \
339 { \
340 svbool_t p0; \
341 INVOKE (CODE1, CODE2); \
342 return p0; \
343 }
344
345 #define TEST_PTEST(NAME, TYPE, CODE) \
346 PROTO (NAME, TYPE, (svbool_t p0, svbool_t p1, svbool_t p2, \
347 svbool_t p3, TYPE x0, TYPE x1)) \
348 { \
349 INVOKE (CODE, CODE); \
350 return x0; \
351 }
352
353 #define TEST_PN(NAME, CODE1, CODE2) \
354 PROTO (NAME, void, (void)) \
355 { \
356 register svcount_t pn0 __asm("pn0"); \
357 register svcount_t pn7 __asm("pn7"); \
358 register svcount_t pn8 __asm("pn8"); \
359 register svcount_t pn15 __asm("pn15"); \
360 INVOKE (CODE1, CODE2); \
361 __asm volatile ("" :: "Upa" (pn0), "Upa" (pn7), \
362 "Upa" (pn8), "Upa" (pn15)); \
363 }
364
365 #define TEST_COUNT_PN(NAME, CODE1, CODE2) \
366 PROTO (NAME, void, (void)) \
367 { \
368 register svcount_t pn0 __asm ("pn0"); \
369 register svcount_t pn7 __asm ("pn7"); \
370 register svcount_t pn8 __asm ("pn8"); \
371 register svcount_t pn15 __asm ("pn15"); \
372 register uint64_t x0 __asm ("x0"); \
373 register uint64_t x15 __asm ("x15"); \
374 register uint64_t x17 __asm ("x17"); \
375 __asm volatile ("" : "=Upa" (pn0), "=Upa" (pn7), \
376 "=Upa" (pn8), "=Upa" (pn15)); \
377 INVOKE (CODE1, CODE2); \
378 __asm volatile ("" :: "r" (x0), "r" (x15), \
379 "r" (x17)); \
380 }
381
382 #define TEST_EXTRACT_PN(NAME, TYPE, CODE1, CODE2) \
383 PROTO (NAME, void, (void)) \
384 { \
385 register svcount_t pn0 __asm ("pn0"); \
386 register TYPE p2 __asm ("p2"); \
387 register TYPE p5 __asm ("p5"); \
388 register svcount_t pn7 __asm ("pn7"); \
389 register svcount_t pn8 __asm ("pn8"); \
390 register TYPE p9 __asm ("p9"); \
391 register svcount_t pn11 __asm ("pn11"); \
392 register TYPE p12 __asm ("p12"); \
393 register svcount_t pn15 __asm ("pn15"); \
394 __asm volatile ("" : "=Upa" (pn0), "=Upa" (pn7), \
395 "=Upa" (pn8), "=Upa" (pn11), \
396 "=Upa" (pn15)); \
397 INVOKE (CODE1, CODE2); \
398 __asm volatile ("" :: "Upa" (p2), "Upa" (p5), \
399 "Upa" (p9), "Upa" (p12)); \
400 }
401
402 #define TEST_SELECT_P(NAME, TYPE, CODE1, CODE2) \
403 PROTO (NAME, void, (void)) \
404 { \
405 register TYPE p0 __asm ("p0"); \
406 register TYPE p2 __asm ("p2"); \
407 register svbool_t p7 __asm ("p7"); \
408 register svbool_t p8 __asm ("p8"); \
409 register TYPE p13 __asm ("p13"); \
410 register svbool_t p15 __asm ("p15"); \
411 register int32_t w11 __asm ("w11"); \
412 register int32_t w12 __asm ("w12"); \
413 register int32_t w15 __asm ("w15"); \
414 register int32_t w16 __asm ("w16"); \
415 __asm volatile ("" : "=Upa" (p0), "=Upa" (p2), \
416 "=Upa" (p7), "=Upa" (p8), \
417 "=Upa" (p13), "=Upa" (p15), \
418 "=r" (w11), "=r" (w12), \
419 "=r" (w15), "=r" (w16)); \
420 INVOKE (CODE1, CODE2); \
421 __asm volatile ("" :: "Upa" (p0), "Upa" (p2), \
422 "Upa" (p7), "Upa" (p8), \
423 "Upa" (p13), "Upa" (p15)); \
424 }
425
426 #define TEST_COMPARE_S(NAME, TYPE, CODE1, CODE2) \
427 PROTO (NAME, svbool_t, (TYPE x0, TYPE x1)) \
428 { \
429 svbool_t p0; \
430 INVOKE (CODE1, CODE2); \
431 return p0; \
432 }
433
434 #define TEST_COMPARE_S_X2(NAME, TYPE, CODE1, CODE2) \
435 PROTO (NAME, void, (TYPE x0, TYPE x1)) \
436 { \
437 register svboolx2_t p1 __asm("p1"); \
438 register svboolx2_t p4 __asm("p4"); \
439 register svboolx2_t p9 __asm("p9"); \
440 register svboolx2_t p14 __asm("p14"); \
441 INVOKE (CODE1, CODE2); \
442 __asm volatile ("" :: "Upa" (p1), "Upa" (p4), \
443 "Upa" (p9), "Upa" (p14)); \
444 }
445
446 #define TEST_COMPARE_S_C(NAME, TYPE, CODE1, CODE2) \
447 PROTO (NAME, void, (TYPE x0, TYPE x1)) \
448 { \
449 register svcount_t pn0 __asm("pn0"); \
450 register svcount_t pn7 __asm("pn7"); \
451 register svcount_t pn8 __asm("pn8"); \
452 register svcount_t pn15 __asm("pn15"); \
453 INVOKE (CODE1, CODE2); \
454 __asm volatile ("" :: "Upa" (pn0), "Upa" (pn7), \
455 "Upa" (pn8), "Upa" (pn15)); \
456 }
457
458 #define TEST_COMPARE_Z(NAME, TYPE, CODE1, CODE2) \
459 PROTO (NAME, svbool_t, (TYPE z0, TYPE z1, \
460 svbool_t p0, svbool_t p1)) \
461 { \
462 INVOKE (CODE1, CODE2); \
463 return p0; \
464 }
465
466 #define TEST_COMPARE_ZX(NAME, ZTYPE, STYPE, CODE1, CODE2) \
467 PROTO (NAME, svbool_t, (ZTYPE z0, ZTYPE z1, svbool_t p0, \
468 svbool_t p1, STYPE x0)) \
469 { \
470 INVOKE (CODE1, CODE2); \
471 return p0; \
472 }
473
474 #define TEST_COMPARE_ZD(NAME, ZTYPE, STYPE, CODE1, CODE2) \
475 PROTO (NAME, svbool_t, (ZTYPE z0, ZTYPE z1, ZTYPE z2, \
476 ZTYPE z3, svbool_t p0, svbool_t p1, \
477 STYPE d4)) \
478 { \
479 INVOKE (CODE1, CODE2); \
480 return p0; \
481 }
482
483 #define TEST_COMPARE_DUAL_Z(NAME, TYPE1, TYPE2, CODE1, CODE2) \
484 PROTO (NAME, svbool_t, (TYPE1 z0, TYPE2 z1, \
485 svbool_t p0, svbool_t p1)) \
486 { \
487 INVOKE (CODE1, CODE2); \
488 return p0; \
489 }
490
491 #define TEST_REDUCTION_X(NAME, STYPE, ZTYPE, CODE1, CODE2) \
492 PROTO (NAME, STYPE, (ZTYPE z0, ZTYPE z1, svbool_t p0)) \
493 { \
494 STYPE x0; \
495 INVOKE (CODE1, CODE2); \
496 return x0; \
497 }
498
499 #define TEST_REDUCTION_D(NAME, STYPE, ZTYPE, CODE1, CODE2) \
500 PROTO (NAME, STYPE, (ZTYPE z0, ZTYPE z1, svbool_t p0)) \
501 { \
502 STYPE d0; \
503 INVOKE (CODE1, CODE2); \
504 return d0; \
505 }
506
507 #define TEST_FOLD_LEFT_D(NAME, STYPE, ZTYPE, CODE1, CODE2) \
508 PROTO (NAME, STYPE, (STYPE d0, STYPE d1, ZTYPE z2, \
509 svbool_t p0)) \
510 { \
511 INVOKE (CODE1, CODE2); \
512 return d0; \
513 }
514
515 #define TEST_FOLD_LEFT_X(NAME, STYPE, ZTYPE, CODE1, CODE2) \
516 PROTO (NAME, STYPE, (STYPE x0, STYPE x1, ZTYPE z0, \
517 svbool_t p0)) \
518 { \
519 INVOKE (CODE1, CODE2); \
520 return x0; \
521 }
522
523 #define TEST_S(NAME, ZTYPE, STYPE, CODE) \
524 PROTO (NAME, ZTYPE, (STYPE x0, STYPE x1)) \
525 { \
526 ZTYPE z0; \
527 CODE; \
528 return z0; \
529 }
530
531 #define TEST_ADR(NAME, TYPE1, TYPE2, CODE1, CODE2) \
532 PROTO (NAME, TYPE1, (TYPE1 z0, TYPE2 z1)) \
533 { \
534 INVOKE (CODE1, CODE2); \
535 return z0; \
536 }
537
538 #define TEST_UNDEF(NAME, TYPE, CODE) \
539 PROTO (NAME, TYPE, (void)) \
540 { \
541 TYPE z0; \
542 CODE; \
543 return z0; \
544 }
545
546 #define TEST_UNDEF_B(NAME, TYPE, CODE) \
547 PROTO (NAME, TYPE, (void)) \
548 { \
549 TYPE p0; \
550 CODE; \
551 return p0; \
552 }
553
554 #define TEST_CREATE(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
555 PROTO (NAME, TTYPE, (ZTYPE unused0, ZTYPE unused1, \
556 ZTYPE unused2, ZTYPE unused3, \
557 ZTYPE z4, ZTYPE z5, ZTYPE z6, ZTYPE z7)) \
558 { \
559 TTYPE z0; \
560 INVOKE (CODE1, CODE2); \
561 return z0; \
562 }
563
564 #define TEST_CREATE_B(NAME, TTYPE, CODE1, CODE2) \
565 PROTO (NAME, TTYPE, (svbool_t p0, svbool_t p1, \
566 svbool_t p2, svbool_t p3)) \
567 { \
568 TTYPE p0_res; \
569 INVOKE (CODE1, CODE2); \
570 return p0_res; \
571 }
572
573 #define TEST_GET(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
574 PROTO (NAME, void, (ZTYPE unused0, ZTYPE unused1, \
575 ZTYPE unused2, ZTYPE unused3, TTYPE z4)) \
576 { \
577 register ZTYPE z0 __asm ("z0"); \
578 register ZTYPE z4_res __asm ("z4"); \
579 register ZTYPE z5_res __asm ("z5"); \
580 register ZTYPE z6_res __asm ("z6"); \
581 register ZTYPE z7_res __asm ("z7"); \
582 INVOKE (CODE1, CODE2); \
583 __asm volatile ("" :: "w" (z0), "w" (z4_res), "w" (z5_res), \
584 "w" (z6_res), "w" (z7_res)); \
585 }
586
587 #define TEST_GET_B(NAME, TTYPE, CODE1, CODE2) \
588 PROTO (NAME, void, (void)) \
589 { \
590 register svbool_t p0 __asm ("p0"); \
591 register TTYPE p4 __asm ("p4"); \
592 register svbool_t p4_res __asm ("p4"); \
593 register svbool_t p5_res __asm ("p5"); \
594 register svbool_t p6_res __asm ("p6"); \
595 register svbool_t p7_res __asm ("p7"); \
596 __asm volatile ("" : "=Upa" (p0), "=Upa" (p4)); \
597 INVOKE (CODE1, CODE2); \
598 __asm volatile ("" :: "Upa" (p0), "Upa" (p4_res), \
599 "Upa" (p5_res), "Upa" (p6_res), \
600 "Upa" (p7_res)); \
601 }
602
603 #define TEST_SET(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
604 PROTO (NAME, void, (ZTYPE z0, ZTYPE z1, ZTYPE z2, ZTYPE z3, \
605 TTYPE z4)) \
606 { \
607 register TTYPE z24 __asm ("z24"); \
608 INVOKE (CODE1, CODE2); \
609 __asm volatile ("" :: "w" (z4), "w" (z24)); \
610 }
611
612 #define TEST_SET_B(NAME, TTYPE, CODE1, CODE2) \
613 PROTO (NAME, void, (void)) \
614 { \
615 register svbool_t p0 __asm ("p0"); \
616 register TTYPE p4 __asm ("p4"); \
617 register TTYPE p8 __asm ("p8"); \
618 register svbool_t p12 __asm ("p12"); \
619 register svbool_t p13 __asm ("p13"); \
620 __asm volatile ("" : "=Upa" (p0), "=Upa" (p4), \
621 "=Upa" (p12), "=Upa" (p13)); \
622 INVOKE (CODE1, CODE2); \
623 __asm volatile ("" :: "Upa" (p4), "Upa" (p8)); \
624 }
625
626 #define TEST_SET_NEONQ(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
627 PROTO (NAME, void, (ZTYPE z0, ZTYPE z1, ZTYPE z2, ZTYPE z3, \
628 TTYPE z4)) \
629 { \
630 register TTYPE z24 __asm ("z24"); \
631 register TTYPE z4_res __asm ("z4"); \
632 INVOKE (CODE1, CODE2); \
633 __asm volatile ("" :: "w" (z24), "w" (z4_res)); \
634 }
635
636 #define TEST_DUP_NEONQ(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
637 PROTO (NAME, void, (ZTYPE unused0, ZTYPE unused1, \
638 ZTYPE unused2, ZTYPE unused3, TTYPE z4)) \
639 { \
640 register ZTYPE z0 __asm ("z0"); \
641 register ZTYPE z4_res __asm ("z4"); \
642 register ZTYPE z5_res __asm ("z5"); \
643 INVOKE (CODE1, CODE2); \
644 __asm volatile ("" :: "w" (z0), "w" (z4_res), \
645 "w" (z5_res)); \
646 }
647
648 #define TEST_TBL2(NAME, TTYPE, ZTYPE, UTYPE, CODE1, CODE2) \
649 PROTO (NAME, ZTYPE, (TTYPE z0, TTYPE z2, UTYPE z4)) \
650 { \
651 register ZTYPE z0_res __asm ("z0"); \
652 INVOKE (CODE1, CODE2); \
653 return z0_res; \
654 }
655
656 #define TEST_TBL2_REV(NAME, TTYPE, ZTYPE, UTYPE, CODE1, CODE2) \
657 PROTO (NAME, ZTYPE, (UTYPE z0, TTYPE z1, TTYPE z3)) \
658 { \
659 register ZTYPE z0_res __asm ("z0"); \
660 INVOKE (CODE1, CODE2); \
661 return z0_res; \
662 }
663
664 #define TEST_XN(NAME, TTYPE, RES, CODE1, CODE2) \
665 PROTO (NAME, void, ()) \
666 { \
667 register TTYPE z0 __asm ("z0"); \
668 register TTYPE z4 __asm ("z4"); \
669 register TTYPE z18 __asm ("z18"); \
670 register TTYPE z23 __asm ("z23"); \
671 register TTYPE z28 __asm ("z28"); \
672 register svcount_t pn0 __asm ("pn0"); \
673 register svcount_t pn7 __asm ("pn7"); \
674 register svcount_t pn8 __asm ("pn8"); \
675 register svcount_t pn15 __asm ("pn15"); \
676 __asm volatile ("" : "=w" (z0), "=w" (z4), "=w" (z18), \
677 "=w" (z23), "=w" (z28), "=Upa" (pn0), \
678 "=Upa" (pn7), "=Upa" (pn8), "=Upa" (pn15)); \
679 INVOKE (RES = CODE1, RES = CODE2); \
680 __asm volatile ("" :: "w" (RES)); \
681 }
682
683 #define TEST_DUAL_XN(NAME, TTYPE1, TTYPE2, RES, CODE1, CODE2) \
684 PROTO (NAME, void, ()) \
685 { \
686 register TTYPE1 z0 __asm ("z0"); \
687 register TTYPE2 z4 __asm ("z4"); \
688 register TTYPE1 z18 __asm ("z18"); \
689 register TTYPE2 z23 __asm ("z23"); \
690 register TTYPE1 z28 __asm ("z28"); \
691 __asm volatile ("" : "=w" (z0), "=w" (z4), "=w" (z18), \
692 "=w" (z23), "=w" (z28)); \
693 INVOKE (RES = CODE1, RES = CODE2); \
694 __asm volatile ("" :: "w" (RES)); \
695 }
696
697 #define TEST_XN_SINGLE(NAME, TTYPE, ZTYPE, RES, CODE1, CODE2) \
698 PROTO (NAME, void, ()) \
699 { \
700 register ZTYPE z0 __asm ("z0"); \
701 register TTYPE z1 __asm ("z1"); \
702 register ZTYPE z5 __asm ("z5"); \
703 register ZTYPE z7 __asm ("z7"); \
704 register ZTYPE z16 __asm ("z16"); \
705 register TTYPE z18 __asm ("z18"); \
706 register ZTYPE z23 __asm ("z23"); \
707 register TTYPE z24 __asm ("z24"); \
708 register TTYPE z28 __asm ("z28"); \
709 __asm volatile ("" : "=w" (z0), "=w" (z1), "=w" (z5), \
710 "=w" (z7), "=w" (z16), "=w" (z18), \
711 "=w" (z23), "=w" (z24), "=w" (z28)); \
712 INVOKE (RES = CODE1, RES = CODE2); \
713 __asm volatile ("" :: "w" (RES)); \
714 }
715
716 #define TEST_XN_SINGLE_Z15(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
717 PROTO (NAME, TTYPE, (TTYPE z0)) \
718 { \
719 register ZTYPE z15 __asm ("z15"); \
720 __asm volatile ("" : "=w" (z15)); \
721 INVOKE (CODE1, CODE2); \
722 return z0; \
723 }
724
725 #define TEST_XN_SINGLE_AWKWARD(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
726 PROTO (NAME, TTYPE, (ZTYPE z0, TTYPE z1, ZTYPE zn)) \
727 { \
728 TTYPE z0_res; \
729 INVOKE (CODE1, CODE2); \
730 return z0_res; \
731 }
732
733 #define TEST_X2_NARROW(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
734 PROTO (NAME, void, ()) \
735 { \
736 register TTYPE z0 __asm ("z0"); \
737 register ZTYPE z5 __asm ("z5"); \
738 register TTYPE z6 __asm ("z6"); \
739 register TTYPE z16 __asm ("z16"); \
740 register ZTYPE z22 __asm ("z22"); \
741 register TTYPE z29 __asm ("z29"); \
742 register ZTYPE z0_res __asm ("z0"); \
743 __asm volatile ("" : "=w" (z0), "=w" (z5), "=w" (z6), \
744 "=w" (z16), "=w" (z22), "=w" (z29)); \
745 INVOKE (CODE1, CODE2); \
746 __asm volatile ("" :: "w" (z0_res), "w" (z5), "w" (z22)); \
747 }
748
749 #define TEST_X4_NARROW(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
750 PROTO (NAME, void, ()) \
751 { \
752 register TTYPE z0 __asm ("z0"); \
753 register TTYPE z4 __asm ("z4"); \
754 register TTYPE z16 __asm ("z16"); \
755 register TTYPE z21 __asm ("z21"); \
756 register ZTYPE z25 __asm ("z25"); \
757 register TTYPE z26 __asm ("z26"); \
758 register ZTYPE z0_res __asm ("z0"); \
759 register ZTYPE z22_res __asm ("z22"); \
760 __asm volatile ("" : "=w" (z0), "=w" (z4), "=w" (z16), \
761 "=w" (z21), "=w" (z26)); \
762 INVOKE (CODE1, CODE2); \
763 __asm volatile ("" :: "w" (z0_res), "w" (z22_res), \
764 "w" (z25)); \
765 }
766
767 #define TEST_X2_WIDE(NAME, TTYPE, ZTYPE, CODE1, CODE2) \
768 PROTO (NAME, void, ()) \
769 { \
770 register ZTYPE z0 __asm ("z0"); \
771 register ZTYPE z5 __asm ("z5"); \
772 register TTYPE z6 __asm ("z6"); \
773 register TTYPE z16 __asm ("z16"); \
774 register ZTYPE z22 __asm ("z22"); \
775 register TTYPE z29 __asm ("z29"); \
776 register TTYPE z0_res __asm ("z0"); \
777 __asm volatile ("" : "=w" (z0), "=w" (z5), "=w" (z22)); \
778 INVOKE (CODE1, CODE2); \
779 __asm volatile ("" :: "w" (z0_res), "w" (z5), "w" (z6), \
780 "w" (z16), "w" (z22), "w" (z29)); \
781 }
782
783 #define TEST_1X2_NARROW(NAME, RTYPE, TTYPE, ZTYPE, CODE1, CODE2) \
784 PROTO(NAME, void, ()) \
785 { \
786 register RTYPE z0 __asm ("z0"); \
787 register TTYPE z5 __asm ("z5"); \
788 register TTYPE z6 __asm ("z6"); \
789 register TTYPE z16 __asm ("z16"); \
790 register ZTYPE z22 __asm ("z22"); \
791 register TTYPE z29 __asm ("z29"); \
792 register RTYPE z0_res __asm ("z0"); \
793 __asm volatile ("" : "=w" (z0), "=w" (z5), "=w" (z6), \
794 "=w" (z16), "=w" (z22), "=w" (z29)); \
795 INVOKE (CODE1, CODE2); \
796 __asm volatile ("" :: "w" (z0_res), "w" (z5), "w" (z22)); \
797 }
798
799 #endif