Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/arm-neon-ref.h

raw
1 /* This file defines helper operations shared by all the tests. */
2
3 #ifndef _ARM_NEON_REF_H_
4 #define _ARM_NEON_REF_H_
5
6 #include <stdio.h>
7 #include <inttypes.h>
8
9 /* helper type, to help write floating point results in integer form. */
10 typedef uint8_t hmfloat8_t;
11 typedef uint16_t hfloat16_t;
12 typedef uint32_t hfloat32_t;
13 typedef uint64_t hfloat64_t;
14
15 typedef uint16_t hbfloat16_t;
16
17 extern void abort(void);
18 extern void *memset(void *, int, size_t);
19 extern void *memcpy(void *, const void *, size_t);
20 extern size_t strlen(const char *);
21
22 /* Helper macro to select FP16 tests. */
23 #if (defined (__ARM_FP16_FORMAT_IEEE) \
24 || defined (__ARM_FP16_FORMAT_ALTERNATIVE))
25 #define FP16_SUPPORTED (1)
26 #else
27 #undef FP16_SUPPORTED
28 #endif
29
30 /* Various string construction helpers. */
31
32 /*
33 The most useful at user-level are VECT_VAR and VECT_VAR_DECL, which
34 construct variable names or declarations, such as:
35 VECT_VAR(expected, int, 16, 4) -> expected_int16x4
36 VECT_VAR_DECL(expected, int, 16, 4) -> int16x4_t expected_int16x4
37 */
38 /* Some instructions don't exist on ARM.
39 Use this macro to guard against them. */
40 #ifdef __aarch64__
41 #define AARCH64_ONLY(X) X
42 #define MFLOAT8_SUPPORTED 1
43 #else
44 #define AARCH64_ONLY(X)
45 #define MFLOAT8_SUPPORTED 0
46 #endif
47
48 #if MFLOAT8_SUPPORTED
49 #define MFLOAT8_ONLY(X) X
50 #define MFLOAT8(X) (((union { uint8_t x; mfloat8_t y; }) { X }).y)
51 #define CONVERT(T, X) \
52 ((T) _Generic ((T){}, mfloat8_t: MFLOAT8(X), default: X))
53 #else
54 #define MFLOAT8_ONLY(X)
55 #define CONVERT(T, X) ((T) X)
56 #endif
57
58 #define BITEQUAL(X, Y) (__builtin_memcmp (&X, &Y, sizeof(X)) == 0)
59
60 #define xSTR(X) #X
61 #define STR(X) xSTR(X)
62
63 #define xNAME1(V,T) V ## _ ## T
64 #define xNAME(V,T) xNAME1(V,T)
65
66 /* VAR(foo,int,16) -> foo_int16 */
67 #define VAR(V,T,W) xNAME(V,T##W)
68 /* VAR_DECL(foo,int,16) -> int16_t foo_int16 */
69 #define VAR_DECL(V, T, W) T##W##_t VAR(V,T,W)
70
71 /* VECT_NAME(int,16,4) -> int16x4 */
72 #define VECT_NAME(T, W, N) T##W##x##N
73 /* VECT_ARRAY_NAME(int,16,4,2) -> int16x4x2 */
74 #define VECT_ARRAY_NAME(T, W, N, L) T##W##x##N##x##L
75 /* VECT_TYPE(int,16,4) -> int16x4_t */
76 #define VECT_TYPE(T, W, N) xNAME(VECT_NAME(T,W,N),t)
77 /* VECT_ARRAY_TYPE(int,16,4,2) -> int16x4x2_t */
78 #define VECT_ARRAY_TYPE(T, W, N, L) xNAME(VECT_ARRAY_NAME(T,W,N,L),t)
79
80 /* VECT_VAR(foo,int,16,4) -> foo_int16x4 */
81 #define VECT_VAR(V,T,W,N) xNAME(V,VECT_NAME(T,W,N))
82 /* VECT_VAR_DECL(foo,int,16,4) -> int16_t foo_int16x4 */
83 #define VECT_VAR_DECL(V, T, W, N) T##W##_t VECT_VAR(V,T,W,N)
84
85 /* Array declarations. */
86 /* ARRAY(foo,int,16,4) -> int16_t foo_int16x4[4] */
87 #define ARRAY(V, T, W, N) VECT_VAR_DECL(V,T,W,N)[N]
88
89 /* Arrays of vectors. */
90 /* VECT_ARRAY_VAR(foo,int,16,4,2) -> foo_int16x4x2 */
91 #define VECT_ARRAY_VAR(V,T,W,N,L) xNAME(V,VECT_ARRAY_NAME(T,W,N,L))
92 /* VECT_ARRAY(foo,int,16,4,2) -> int16_t foo_int16x4x2[4*2] */
93 #define VECT_ARRAY(V, T, W, N, L) T##W##_t VECT_ARRAY_VAR(V,T,W,N,L)[N*L]
94
95 /* Check results vs expected values. Operates on one vector. */
96 #define CHECK(MSG,T,W,N,FMT,EXPECTED,COMMENT) \
97 { \
98 int i; \
99 for(i=0; i<N ; i++) \
100 { \
101 if (VECT_VAR(result, T, W, N)[i] != \
102 VECT_VAR(EXPECTED, T, W, N)[i]) { \
103 fprintf(stderr, \
104 "ERROR in %s (%s line %d in buffer '%s') at type %s " \
105 "index %d: got 0x%" FMT " != 0x%" FMT " %s\n", \
106 MSG, __FILE__, __LINE__, \
107 STR(EXPECTED), \
108 STR(VECT_NAME(T, W, N)), \
109 i, \
110 VECT_VAR(result, T, W, N)[i], \
111 VECT_VAR(EXPECTED, T, W, N)[i], \
112 strlen(COMMENT) > 0 ? COMMENT : ""); \
113 abort(); \
114 } \
115 } \
116 fprintf(stderr, "CHECKED %s %s\n", STR(VECT_TYPE(T, W, N)), MSG); \
117 }
118
119 /* Floating-point variant. */
120 #define CHECK_FP(MSG,T,W,N,FMT,EXPECTED,COMMENT) \
121 { \
122 int i; \
123 for(i=0; i<N ; i++) \
124 { \
125 union fp_operand { \
126 uint##W##_t i; \
127 T##W##_t f; \
128 } tmp_res, tmp_exp; \
129 tmp_res.f = VECT_VAR(result, T, W, N)[i]; \
130 tmp_exp.i = VECT_VAR(EXPECTED, h##T, W, N)[i]; \
131 if (tmp_res.i != tmp_exp.i) { \
132 fprintf(stderr, \
133 "ERROR in %s (%s line %d in buffer '%s') at type %s " \
134 "index %d: got 0x%" FMT " != 0x%" FMT " %s\n", \
135 MSG, __FILE__, __LINE__, \
136 STR(EXPECTED), \
137 STR(VECT_NAME(T, W, N)), \
138 i, \
139 tmp_res.i, \
140 tmp_exp.i, \
141 strlen(COMMENT) > 0 ? COMMENT : ""); \
142 abort(); \
143 } \
144 } \
145 fprintf(stderr, "CHECKED %s %s\n", STR(VECT_TYPE(T, W, N)), MSG); \
146 }
147
148 /* poly variant. */
149 #define CHECK_POLY(MSG,T,W,N,FMT,EXPECTED,COMMENT) \
150 { \
151 int i; \
152 for(i=0; i<N ; i++) \
153 { \
154 union poly_operand { \
155 uint##W##_t i; \
156 poly##W##_t p; \
157 } tmp_res, tmp_exp; \
158 tmp_res.p = VECT_VAR(result, T, W, N)[i]; \
159 tmp_exp.i = VECT_VAR(EXPECTED, T, W, N)[i]; \
160 if (tmp_res.i != tmp_exp.i) { \
161 fprintf(stderr, \
162 "ERROR in %s (%s line %d in buffer '%s') at type %s " \
163 "index %d: got 0x%" FMT " != 0x%" FMT " %s\n", \
164 MSG, __FILE__, __LINE__, \
165 STR(EXPECTED), \
166 STR(VECT_NAME(T, W, N)), \
167 i, \
168 tmp_res.i, \
169 tmp_exp.i, \
170 strlen(COMMENT) > 0 ? COMMENT : ""); \
171 abort(); \
172 } \
173 } \
174 fprintf(stderr, "CHECKED %s %s\n", STR(VECT_TYPE(T, W, N)), MSG); \
175 }
176
177 /* Clean buffer with a non-zero pattern to help diagnose buffer
178 overflows. */
179 #define CLEAN_PATTERN_8 0x33
180
181 #define CLEAN(VAR,T,W,N) \
182 memset(VECT_VAR(VAR, T, W, N), \
183 CLEAN_PATTERN_8, \
184 sizeof(VECT_VAR(VAR, T, W, N)));
185
186 /* Define output buffers, one of each size. */
187 static ARRAY(result, int, 8, 8);
188 static ARRAY(result, int, 16, 4);
189 static ARRAY(result, int, 32, 2);
190 static ARRAY(result, int, 64, 1);
191 static ARRAY(result, uint, 8, 8);
192 static ARRAY(result, uint, 16, 4);
193 static ARRAY(result, uint, 32, 2);
194 static ARRAY(result, uint, 64, 1);
195 static ARRAY(result, poly, 8, 8);
196 static ARRAY(result, poly, 16, 4);
197 #if defined (__ARM_FEATURE_CRYPTO)
198 static ARRAY(result, poly, 64, 1);
199 #endif
200 #if MFLOAT8_SUPPORTED
201 static ARRAY(result, mfloat, 8, 8);
202 #endif
203 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
204 static ARRAY(result, float, 16, 4);
205 #endif
206 static ARRAY(result, float, 32, 2);
207 #ifdef __aarch64__
208 static ARRAY(result, float, 64, 1);
209 #endif
210 static ARRAY(result, int, 8, 16);
211 static ARRAY(result, int, 16, 8);
212 static ARRAY(result, int, 32, 4);
213 static ARRAY(result, int, 64, 2);
214 static ARRAY(result, uint, 8, 16);
215 static ARRAY(result, uint, 16, 8);
216 static ARRAY(result, uint, 32, 4);
217 static ARRAY(result, uint, 64, 2);
218 static ARRAY(result, poly, 8, 16);
219 static ARRAY(result, poly, 16, 8);
220 #if defined (__ARM_FEATURE_CRYPTO)
221 static ARRAY(result, poly, 64, 2);
222 #endif
223 #if MFLOAT8_SUPPORTED
224 static ARRAY(result, mfloat, 8, 16);
225 #endif
226 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
227 static ARRAY(result, float, 16, 8);
228 #endif
229 static ARRAY(result, float, 32, 4);
230 #ifdef __aarch64__
231 static ARRAY(result, float, 64, 2);
232 #endif
233
234 /* Declare expected results, one of each size. They are defined and
235 initialized in each test file. */
236 extern ARRAY(expected, int, 8, 8);
237 extern ARRAY(expected, int, 16, 4);
238 extern ARRAY(expected, int, 32, 2);
239 extern ARRAY(expected, int, 64, 1);
240 extern ARRAY(expected, uint, 8, 8);
241 extern ARRAY(expected, uint, 16, 4);
242 extern ARRAY(expected, uint, 32, 2);
243 extern ARRAY(expected, uint, 64, 1);
244 extern ARRAY(expected, poly, 8, 8);
245 extern ARRAY(expected, poly, 16, 4);
246 #if MFLOAT8_SUPPORTED
247 extern ARRAY(expected, hmfloat, 8, 8);
248 #endif
249 extern ARRAY(expected, hfloat, 16, 4);
250 extern ARRAY(expected, hfloat, 32, 2);
251 extern ARRAY(expected, hfloat, 64, 1);
252 extern ARRAY(expected, int, 8, 16);
253 extern ARRAY(expected, int, 16, 8);
254 extern ARRAY(expected, int, 32, 4);
255 extern ARRAY(expected, int, 64, 2);
256 extern ARRAY(expected, uint, 8, 16);
257 extern ARRAY(expected, uint, 16, 8);
258 extern ARRAY(expected, uint, 32, 4);
259 extern ARRAY(expected, uint, 64, 2);
260 extern ARRAY(expected, poly, 8, 16);
261 extern ARRAY(expected, poly, 16, 8);
262 #if MFLOAT8_SUPPORTED
263 extern ARRAY(expected, hmfloat, 8, 16);
264 #endif
265 extern ARRAY(expected, hfloat, 16, 8);
266 extern ARRAY(expected, hfloat, 32, 4);
267 extern ARRAY(expected, hfloat, 64, 2);
268
269 #define CHECK_RESULTS_NAMED_NO_FP16(test_name,EXPECTED,comment) \
270 { \
271 CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment); \
272 CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment); \
273 CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment); \
274 CHECK(test_name, int, 64, 1, PRIx64, EXPECTED, comment); \
275 CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment); \
276 CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment); \
277 CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment); \
278 CHECK(test_name, uint, 64, 1, PRIx64, EXPECTED, comment); \
279 CHECK_POLY(test_name, poly, 8, 8, PRIx8, EXPECTED, comment); \
280 CHECK_POLY(test_name, poly, 16, 4, PRIx16, EXPECTED, comment); \
281 MFLOAT8_ONLY(CHECK_FP(test_name, mfloat, 8, 8, PRIx8, \
282 EXPECTED, comment);) \
283 CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment); \
284 \
285 CHECK(test_name, int, 8, 16, PRIx8, EXPECTED, comment); \
286 CHECK(test_name, int, 16, 8, PRIx16, EXPECTED, comment); \
287 CHECK(test_name, int, 32, 4, PRIx32, EXPECTED, comment); \
288 CHECK(test_name, int, 64, 2, PRIx64, EXPECTED, comment); \
289 CHECK(test_name, uint, 8, 16, PRIx8, EXPECTED, comment); \
290 CHECK(test_name, uint, 16, 8, PRIx16, EXPECTED, comment); \
291 CHECK(test_name, uint, 32, 4, PRIx32, EXPECTED, comment); \
292 CHECK(test_name, uint, 64, 2, PRIx64, EXPECTED, comment); \
293 CHECK_POLY(test_name, poly, 8, 16, PRIx8, EXPECTED, comment); \
294 CHECK_POLY(test_name, poly, 16, 8, PRIx16, EXPECTED, comment); \
295 MFLOAT8_ONLY(CHECK_FP(test_name, mfloat, 8, 16, PRIx8, \
296 EXPECTED, comment);) \
297 CHECK_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment); \
298 } \
299
300 /* Check results against EXPECTED. Operates on all possible vector types. */
301 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
302 #define CHECK_RESULTS_NAMED(test_name,EXPECTED,comment) \
303 { \
304 CHECK_RESULTS_NAMED_NO_FP16(test_name, EXPECTED, comment) \
305 CHECK_FP(test_name, float, 16, 4, PRIx16, EXPECTED, comment); \
306 CHECK_FP(test_name, float, 16, 8, PRIx16, EXPECTED, comment); \
307 }
308 #else
309 #define CHECK_RESULTS_NAMED(test_name,EXPECTED,comment) \
310 CHECK_RESULTS_NAMED_NO_FP16(test_name, EXPECTED, comment)
311 #endif
312
313 #define CHECK_RESULTS_NO_FP16(test_name,comment) \
314 CHECK_RESULTS_NAMED_NO_FP16(test_name, expected, comment)
315
316 #define CHECK_RESULTS(test_name,comment) \
317 CHECK_RESULTS_NAMED(test_name, expected, comment)
318
319
320 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
321
322 typedef union {
323 struct {
324 int _xxx:24;
325 unsigned int FZ:1;
326 unsigned int DN:1;
327 unsigned int AHP:1;
328 unsigned int QC:1;
329 int V:1;
330 int C:1;
331 int Z:1;
332 int N:1;
333 } b;
334 unsigned int word;
335 } _ARM_FPSCR;
336
337 #else /* __ORDER_BIG_ENDIAN__ */
338
339 typedef union {
340 struct {
341 int N:1;
342 int Z:1;
343 int C:1;
344 int V:1;
345 unsigned int QC:1;
346 unsigned int AHP:1;
347 unsigned int DN:1;
348 unsigned int FZ:1;
349 int _dnm:24;
350 } b;
351 unsigned int word;
352 } _ARM_FPSCR;
353
354 #endif /* __ORDER_BIG_ENDIAN__ */
355
356 #define Neon_Cumulative_Sat __read_neon_cumulative_sat()
357 /* We need a fake dependency to ensure correct ordering of asm
358 statements to preset the QC flag value, and Neon operators writing
359 to QC. */
360 #define Set_Neon_Cumulative_Sat(x, depend) \
361 __set_neon_cumulative_sat((x), (depend))
362
363 #if defined(__aarch64__)
364 static volatile int __read_neon_cumulative_sat (void) {
365 _ARM_FPSCR _afpscr_for_qc;
366 asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc));
367 return _afpscr_for_qc.b.QC;
368 }
369 #define __set_neon_cumulative_sat(x, depend) { \
370 _ARM_FPSCR _afpscr_for_qc; \
371 asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc)); \
372 _afpscr_for_qc.b.QC = x; \
373 asm volatile ("msr fpsr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \
374 }
375 #else
376 static volatile int __read_neon_cumulative_sat (void) {
377 _ARM_FPSCR _afpscr_for_qc;
378 asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc));
379 return _afpscr_for_qc.b.QC;
380 }
381
382 #define __set_neon_cumulative_sat(x, depend) { \
383 _ARM_FPSCR _afpscr_for_qc; \
384 asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc)); \
385 _afpscr_for_qc.b.QC = x; \
386 asm volatile ("vmsr fpscr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \
387 }
388 #endif
389
390 /* Clean output buffers before execution. */
391 static void clean_results (void)
392 {
393 CLEAN(result, int, 8, 8);
394 CLEAN(result, int, 16, 4);
395 CLEAN(result, int, 32, 2);
396 CLEAN(result, int, 64, 1);
397 CLEAN(result, uint, 8, 8);
398 CLEAN(result, uint, 16, 4);
399 CLEAN(result, uint, 32, 2);
400 CLEAN(result, uint, 64, 1);
401 CLEAN(result, poly, 8, 8);
402 CLEAN(result, poly, 16, 4);
403 #if defined (__ARM_FEATURE_CRYPTO)
404 CLEAN(result, poly, 64, 1);
405 #endif
406 #if MFLOAT8_SUPPORTED
407 CLEAN(result, mfloat, 8, 8);
408 #endif
409 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
410 CLEAN(result, float, 16, 4);
411 #endif
412 CLEAN(result, float, 32, 2);
413
414 CLEAN(result, int, 8, 16);
415 CLEAN(result, int, 16, 8);
416 CLEAN(result, int, 32, 4);
417 CLEAN(result, int, 64, 2);
418 CLEAN(result, uint, 8, 16);
419 CLEAN(result, uint, 16, 8);
420 CLEAN(result, uint, 32, 4);
421 CLEAN(result, uint, 64, 2);
422 CLEAN(result, poly, 8, 16);
423 CLEAN(result, poly, 16, 8);
424 #if defined (__ARM_FEATURE_CRYPTO)
425 CLEAN(result, poly, 64, 2);
426 #endif
427 #if MFLOAT8_SUPPORTED
428 CLEAN(result, mfloat, 8, 16);
429 #endif
430 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
431 CLEAN(result, float, 16, 8);
432 #endif
433 CLEAN(result, float, 32, 4);
434
435 AARCH64_ONLY(CLEAN(result, float, 64, 2));
436
437 #if defined(__aarch64__)
438 /* On AArch64, make sure to return DefaultNaN to have the same
439 results as on AArch32. */
440 _ARM_FPSCR _afpscr;
441 asm volatile ("mrs %0,fpcr" : "=r" (_afpscr));
442 _afpscr.b.DN = 1;
443
444 /* On AArch64, make sure to flush to zero by default, as on
445 AArch32. */
446 _afpscr.b.FZ = 1;
447
448 asm volatile ("msr fpcr,%0" : : "r" (_afpscr));
449 #endif
450 }
451
452
453 /* Helpers to declare variables of various types. */
454 #define DECL_VARIABLE(VAR, T1, W, N) \
455 VECT_TYPE(T1, W, N) VECT_VAR(VAR, T1, W, N)
456
457 #if defined (__ARM_FEATURE_CRYPTO)
458 #define DECL_VARIABLE_CRYPTO(VAR, T1, W, N) \
459 DECL_VARIABLE(VAR, T1, W, N)
460 #else
461 #define DECL_VARIABLE_CRYPTO(VAR, T1, W, N)
462 #endif
463
464 /* Declare only 64 bits signed variants. */
465 #define DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR) \
466 DECL_VARIABLE(VAR, int, 8, 8); \
467 DECL_VARIABLE(VAR, int, 16, 4); \
468 DECL_VARIABLE(VAR, int, 32, 2); \
469 DECL_VARIABLE(VAR, int, 64, 1)
470
471 /* Declare only 64 bits unsigned variants. */
472 #define DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR) \
473 DECL_VARIABLE(VAR, uint, 8, 8); \
474 DECL_VARIABLE(VAR, uint, 16, 4); \
475 DECL_VARIABLE(VAR, uint, 32, 2); \
476 DECL_VARIABLE(VAR, uint, 64, 1)
477
478 /* Declare only 128 bits signed variants. */
479 #define DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR) \
480 DECL_VARIABLE(VAR, int, 8, 16); \
481 DECL_VARIABLE(VAR, int, 16, 8); \
482 DECL_VARIABLE(VAR, int, 32, 4); \
483 DECL_VARIABLE(VAR, int, 64, 2)
484
485 /* Declare only 128 bits unsigned variants. */
486 #define DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR) \
487 DECL_VARIABLE(VAR, uint, 8, 16); \
488 DECL_VARIABLE(VAR, uint, 16, 8); \
489 DECL_VARIABLE(VAR, uint, 32, 4); \
490 DECL_VARIABLE(VAR, uint, 64, 2)
491
492 /* Declare all 64 bits variants. */
493 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
494 #define DECL_VARIABLE_64BITS_VARIANTS(VAR) \
495 DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \
496 DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \
497 DECL_VARIABLE(VAR, poly, 8, 8); \
498 DECL_VARIABLE(VAR, poly, 16, 4); \
499 DECL_VARIABLE_CRYPTO(VAR, poly, 64, 1); \
500 MFLOAT8_ONLY(DECL_VARIABLE(VAR, mfloat, 8, 8);) \
501 DECL_VARIABLE(VAR, float, 16, 4); \
502 DECL_VARIABLE(VAR, float, 32, 2)
503 #else
504 #define DECL_VARIABLE_64BITS_VARIANTS(VAR) \
505 DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \
506 DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \
507 DECL_VARIABLE(VAR, poly, 8, 8); \
508 DECL_VARIABLE(VAR, poly, 16, 4); \
509 DECL_VARIABLE_CRYPTO(VAR, poly, 64, 1); \
510 DECL_VARIABLE(VAR, float, 32, 2)
511 #endif
512
513 /* Declare all 128 bits variants. */
514 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
515 #define DECL_VARIABLE_128BITS_VARIANTS(VAR) \
516 DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR); \
517 DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR); \
518 DECL_VARIABLE(VAR, poly, 8, 16); \
519 DECL_VARIABLE(VAR, poly, 16, 8); \
520 DECL_VARIABLE_CRYPTO(VAR, poly, 64, 2); \
521 MFLOAT8_ONLY(DECL_VARIABLE(VAR, mfloat, 8, 16);) \
522 DECL_VARIABLE(VAR, float, 16, 8); \
523 DECL_VARIABLE(VAR, float, 32, 4); \
524 AARCH64_ONLY(DECL_VARIABLE(VAR, float, 64, 2))
525 #else
526 #define DECL_VARIABLE_128BITS_VARIANTS(VAR) \
527 DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR); \
528 DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR); \
529 DECL_VARIABLE(VAR, poly, 8, 16); \
530 DECL_VARIABLE(VAR, poly, 16, 8); \
531 DECL_VARIABLE_CRYPTO(VAR, poly, 64, 2); \
532 MFLOAT8_ONLY(DECL_VARIABLE(VAR, mfloat, 8, 16);) \
533 DECL_VARIABLE(VAR, float, 32, 4); \
534 AARCH64_ONLY(DECL_VARIABLE(VAR, float, 64, 2))
535 #endif
536 /* Declare all variants. */
537 #define DECL_VARIABLE_ALL_VARIANTS(VAR) \
538 DECL_VARIABLE_64BITS_VARIANTS(VAR); \
539 DECL_VARIABLE_128BITS_VARIANTS(VAR)
540
541 /* Declare all signed variants. */
542 #define DECL_VARIABLE_SIGNED_VARIANTS(VAR) \
543 DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \
544 DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR)
545
546 /* Declare all unsigned variants. */
547 #define DECL_VARIABLE_UNSIGNED_VARIANTS(VAR) \
548 DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \
549 DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR)
550
551 /* Helpers to initialize vectors. */
552 #define VDUP(VAR, Q, T1, T2, W, N, V) \
553 VECT_VAR(VAR, T1, W, N) = vdup##Q##_n_##T2##W(V)
554
555 #define VSET_LANE(VAR, Q, T1, T2, W, N, L, V) \
556 VECT_VAR(VAR, T1, W, N) = vset##Q##_lane_##T2##W(V, \
557 VECT_VAR(VAR, T1, W, N), \
558 L)
559
560 /* We need to load initial values first, so rely on VLD1. */
561 #define VLOAD(VAR, BUF, Q, T1, T2, W, N) \
562 VECT_VAR(VAR, T1, W, N) = vld1##Q##_##T2##W(VECT_VAR(BUF, T1, W, N))
563
564 /* Helpers to call macros with 1 constant and 5 variable
565 arguments. */
566 #if defined (__ARM_FEATURE_CRYPTO)
567 #define MACRO_CRYPTO(MACRO, VAR1, VAR2, T1, T2, T3, W, N) \
568 MACRO(VAR1, VAR2, T1, T2, T3, W, N)
569 #else
570 #define MACRO_CRYPTO(MACRO, VAR1, VAR2, T1, T2, T3, W, N)
571 #endif
572
573 #define TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) \
574 MACRO(VAR, , int, s, 8, 8); \
575 MACRO(VAR, , int, s, 16, 4); \
576 MACRO(VAR, , int, s, 32, 2); \
577 MACRO(VAR, , int, s, 64, 1)
578
579 #define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR) \
580 MACRO(VAR, , uint, u, 8, 8); \
581 MACRO(VAR, , uint, u, 16, 4); \
582 MACRO(VAR, , uint, u, 32, 2); \
583 MACRO(VAR, , uint, u, 64, 1)
584
585 #define TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) \
586 MACRO(VAR, q, int, s, 8, 16); \
587 MACRO(VAR, q, int, s, 16, 8); \
588 MACRO(VAR, q, int, s, 32, 4); \
589 MACRO(VAR, q, int, s, 64, 2)
590
591 #define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO,VAR) \
592 MACRO(VAR, q, uint, u, 8, 16); \
593 MACRO(VAR, q, uint, u, 16, 8); \
594 MACRO(VAR, q, uint, u, 32, 4); \
595 MACRO(VAR, q, uint, u, 64, 2)
596
597 #define TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR) \
598 TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \
599 TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)
600
601 #define TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR) \
602 TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \
603 TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)
604
605 #define TEST_MACRO_ALL_VARIANTS_1_5(MACRO, VAR) \
606 TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR); \
607 TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR)
608
609 #define TEST_MACRO_SIGNED_VARIANTS_1_5(MACRO, VAR) \
610 TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \
611 TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR)
612
613 /* Helpers to call macros with 2 constant and 5 variable
614 arguments. */
615 #define TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
616 MACRO(VAR1, VAR2, , int, s, 8, 8); \
617 MACRO(VAR1, VAR2, , int, s, 16, 4); \
618 MACRO(VAR1, VAR2, , int, s, 32, 2); \
619 MACRO(VAR1, VAR2 , , int, s, 64, 1)
620
621 #define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
622 MACRO(VAR1, VAR2, , uint, u, 8, 8); \
623 MACRO(VAR1, VAR2, , uint, u, 16, 4); \
624 MACRO(VAR1, VAR2, , uint, u, 32, 2); \
625 MACRO(VAR1, VAR2, , uint, u, 64, 1)
626
627 #define TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
628 MACRO(VAR1, VAR2, q, int, s, 8, 16); \
629 MACRO(VAR1, VAR2, q, int, s, 16, 8); \
630 MACRO(VAR1, VAR2, q, int, s, 32, 4); \
631 MACRO(VAR1, VAR2, q, int, s, 64, 2)
632
633 #define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
634 MACRO(VAR1, VAR2, q, uint, u, 8, 16); \
635 MACRO(VAR1, VAR2, q, uint, u, 16, 8); \
636 MACRO(VAR1, VAR2, q, uint, u, 32, 4); \
637 MACRO(VAR1, VAR2, q, uint, u, 64, 2)
638
639 #define TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) \
640 TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
641 TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
642 MACRO(VAR1, VAR2, , poly, p, 8, 8); \
643 MACRO(VAR1, VAR2, , poly, p, 16, 4); \
644 MACRO_CRYPTO(MACRO, VAR1, VAR2, , poly, p, 64, 1)
645
646 #define TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) \
647 TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
648 TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
649 MACRO(VAR1, VAR2, q, poly, p, 8, 16); \
650 MACRO(VAR1, VAR2, q, poly, p, 16, 8); \
651 MACRO_CRYPTO(MACRO, VAR1, VAR2, q, poly, p, 64, 2)
652
653 #define TEST_MACRO_ALL_VARIANTS_2_5(MACRO, VAR1, VAR2) \
654 TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2); \
655 TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2)
656
657 #define TEST_MACRO_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
658 TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
659 TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)
660
661 #endif /* _ARM_NEON_REF_H_ */