Viewing file:  arm-neon-ref.h (20.55 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* This file defines helper operations shared by all the tests. */
#ifndef _ARM_NEON_REF_H_
#define _ARM_NEON_REF_H_
#include <stdio.h>
#include <inttypes.h>
/* helper type, to help write floating point results in integer form. */
typedef uint16_t hfloat16_t;
typedef uint32_t hfloat32_t;
typedef uint64_t hfloat64_t;
typedef uint16_t hbfloat16_t;
extern void abort(void);
extern void *memset(void *, int, size_t);
extern void *memcpy(void *, const void *, size_t);
extern size_t strlen(const char *);
/* Helper macro to select FP16 tests. */
#if (defined (__ARM_FP16_FORMAT_IEEE) \
|| defined (__ARM_FP16_FORMAT_ALTERNATIVE))
#define FP16_SUPPORTED (1)
#else
#undef FP16_SUPPORTED
#endif
/* Various string construction helpers. */
/*
The most useful at user-level are VECT_VAR and VECT_VAR_DECL, which
construct variable names or declarations, such as:
VECT_VAR(expected, int, 16, 4) -> expected_int16x4
VECT_VAR_DECL(expected, int, 16, 4) -> int16x4_t expected_int16x4
*/
/* Some instructions don't exist on ARM.
Use this macro to guard against them. */
#ifdef __aarch64__
#define AARCH64_ONLY(X) X
#else
#define AARCH64_ONLY(X)
#endif
#define xSTR(X) #X
#define STR(X) xSTR(X)
#define xNAME1(V,T) V ## _ ## T
#define xNAME(V,T) xNAME1(V,T)
/* VAR(foo,int,16) -> foo_int16 */
#define VAR(V,T,W) xNAME(V,T##W)
/* VAR_DECL(foo,int,16) -> int16_t foo_int16 */
#define VAR_DECL(V, T, W) T##W##_t VAR(V,T,W)
/* VECT_NAME(int,16,4) -> int16x4 */
#define VECT_NAME(T, W, N) T##W##x##N
/* VECT_ARRAY_NAME(int,16,4,2) -> int16x4x2 */
#define VECT_ARRAY_NAME(T, W, N, L) T##W##x##N##x##L
/* VECT_TYPE(int,16,4) -> int16x4_t */
#define VECT_TYPE(T, W, N) xNAME(VECT_NAME(T,W,N),t)
/* VECT_ARRAY_TYPE(int,16,4,2) -> int16x4x2_t */
#define VECT_ARRAY_TYPE(T, W, N, L) xNAME(VECT_ARRAY_NAME(T,W,N,L),t)
/* VECT_VAR(foo,int,16,4) -> foo_int16x4 */
#define VECT_VAR(V,T,W,N) xNAME(V,VECT_NAME(T,W,N))
/* VECT_VAR_DECL(foo,int,16,4) -> int16_t foo_int16x4 */
#define VECT_VAR_DECL(V, T, W, N) T##W##_t VECT_VAR(V,T,W,N)
/* Array declarations. */
/* ARRAY(foo,int,16,4) -> int16_t foo_int16x4[4] */
#define ARRAY(V, T, W, N) VECT_VAR_DECL(V,T,W,N)[N]
/* Arrays of vectors. */
/* VECT_ARRAY_VAR(foo,int,16,4,2) -> foo_int16x4x2 */
#define VECT_ARRAY_VAR(V,T,W,N,L) xNAME(V,VECT_ARRAY_NAME(T,W,N,L))
/* VECT_ARRAY(foo,int,16,4,2) -> int16_t foo_int16x4x2[4*2] */
#define VECT_ARRAY(V, T, W, N, L) T##W##_t VECT_ARRAY_VAR(V,T,W,N,L)[N*L]
/* Check results vs expected values. Operates on one vector. */
#define CHECK(MSG,T,W,N,FMT,EXPECTED,COMMENT) \
{ \
int i; \
for(i=0; i<N ; i++) \
{ \
if (VECT_VAR(result, T, W, N)[i] != \
VECT_VAR(EXPECTED, T, W, N)[i]) { \
fprintf(stderr, \
"ERROR in %s (%s line %d in buffer '%s') at type %s " \
"index %d: got 0x%" FMT " != 0x%" FMT " %s\n", \
MSG, __FILE__, __LINE__, \
STR(EXPECTED), \
STR(VECT_NAME(T, W, N)), \
i, \
VECT_VAR(result, T, W, N)[i], \
VECT_VAR(EXPECTED, T, W, N)[i], \
strlen(COMMENT) > 0 ? COMMENT : ""); \
abort(); \
} \
} \
fprintf(stderr, "CHECKED %s %s\n", STR(VECT_TYPE(T, W, N)), MSG); \
}
/* Floating-point variant. */
#define CHECK_FP(MSG,T,W,N,FMT,EXPECTED,COMMENT) \
{ \
int i; \
for(i=0; i<N ; i++) \
{ \
union fp_operand { \
uint##W##_t i; \
T##W##_t f; \
} tmp_res, tmp_exp; \
tmp_res.f = VECT_VAR(result, T, W, N)[i]; \
tmp_exp.i = VECT_VAR(EXPECTED, h##T, W, N)[i]; \
if (tmp_res.i != tmp_exp.i) { \
fprintf(stderr, \
"ERROR in %s (%s line %d in buffer '%s') at type %s " \
"index %d: got 0x%" FMT " != 0x%" FMT " %s\n", \
MSG, __FILE__, __LINE__, \
STR(EXPECTED), \
STR(VECT_NAME(T, W, N)), \
i, \
tmp_res.i, \
tmp_exp.i, \
strlen(COMMENT) > 0 ? COMMENT : ""); \
abort(); \
} \
} \
fprintf(stderr, "CHECKED %s %s\n", STR(VECT_TYPE(T, W, N)), MSG); \
}
/* poly variant. */
#define CHECK_POLY(MSG,T,W,N,FMT,EXPECTED,COMMENT) \
{ \
int i; \
for(i=0; i<N ; i++) \
{ \
union poly_operand { \
uint##W##_t i; \
poly##W##_t p; \
} tmp_res, tmp_exp; \
tmp_res.p = VECT_VAR(result, T, W, N)[i]; \
tmp_exp.i = VECT_VAR(EXPECTED, T, W, N)[i]; \
if (tmp_res.i != tmp_exp.i) { \
fprintf(stderr, \
"ERROR in %s (%s line %d in buffer '%s') at type %s " \
"index %d: got 0x%" FMT " != 0x%" FMT " %s\n", \
MSG, __FILE__, __LINE__, \
STR(EXPECTED), \
STR(VECT_NAME(T, W, N)), \
i, \
tmp_res.i, \
tmp_exp.i, \
strlen(COMMENT) > 0 ? COMMENT : ""); \
abort(); \
} \
} \
fprintf(stderr, "CHECKED %s %s\n", STR(VECT_TYPE(T, W, N)), MSG); \
}
/* Clean buffer with a non-zero pattern to help diagnose buffer
overflows. */
#define CLEAN_PATTERN_8 0x33
#define CLEAN(VAR,T,W,N) \
memset(VECT_VAR(VAR, T, W, N), \
CLEAN_PATTERN_8, \
sizeof(VECT_VAR(VAR, T, W, N)));
/* Define output buffers, one of each size. */
static ARRAY(result, int, 8, 8);
static ARRAY(result, int, 16, 4);
static ARRAY(result, int, 32, 2);
static ARRAY(result, int, 64, 1);
static ARRAY(result, uint, 8, 8);
static ARRAY(result, uint, 16, 4);
static ARRAY(result, uint, 32, 2);
static ARRAY(result, uint, 64, 1);
static ARRAY(result, poly, 8, 8);
static ARRAY(result, poly, 16, 4);
#if defined (__ARM_FEATURE_CRYPTO)
static ARRAY(result, poly, 64, 1);
#endif
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
static ARRAY(result, float, 16, 4);
#endif
static ARRAY(result, float, 32, 2);
#ifdef __aarch64__
static ARRAY(result, float, 64, 1);
#endif
static ARRAY(result, int, 8, 16);
static ARRAY(result, int, 16, 8);
static ARRAY(result, int, 32, 4);
static ARRAY(result, int, 64, 2);
static ARRAY(result, uint, 8, 16);
static ARRAY(result, uint, 16, 8);
static ARRAY(result, uint, 32, 4);
static ARRAY(result, uint, 64, 2);
static ARRAY(result, poly, 8, 16);
static ARRAY(result, poly, 16, 8);
#if defined (__ARM_FEATURE_CRYPTO)
static ARRAY(result, poly, 64, 2);
#endif
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
static ARRAY(result, float, 16, 8);
#endif
static ARRAY(result, float, 32, 4);
#ifdef __aarch64__
static ARRAY(result, float, 64, 2);
#endif
/* Declare expected results, one of each size. They are defined and
initialized in each test file. */
extern ARRAY(expected, int, 8, 8);
extern ARRAY(expected, int, 16, 4);
extern ARRAY(expected, int, 32, 2);
extern ARRAY(expected, int, 64, 1);
extern ARRAY(expected, uint, 8, 8);
extern ARRAY(expected, uint, 16, 4);
extern ARRAY(expected, uint, 32, 2);
extern ARRAY(expected, uint, 64, 1);
extern ARRAY(expected, poly, 8, 8);
extern ARRAY(expected, poly, 16, 4);
extern ARRAY(expected, hfloat, 16, 4);
extern ARRAY(expected, hfloat, 32, 2);
extern ARRAY(expected, hfloat, 64, 1);
extern ARRAY(expected, int, 8, 16);
extern ARRAY(expected, int, 16, 8);
extern ARRAY(expected, int, 32, 4);
extern ARRAY(expected, int, 64, 2);
extern ARRAY(expected, uint, 8, 16);
extern ARRAY(expected, uint, 16, 8);
extern ARRAY(expected, uint, 32, 4);
extern ARRAY(expected, uint, 64, 2);
extern ARRAY(expected, poly, 8, 16);
extern ARRAY(expected, poly, 16, 8);
extern ARRAY(expected, hfloat, 16, 8);
extern ARRAY(expected, hfloat, 32, 4);
extern ARRAY(expected, hfloat, 64, 2);
#define CHECK_RESULTS_NAMED_NO_FP16(test_name,EXPECTED,comment) \
{ \
CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment); \
CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment); \
CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment); \
CHECK(test_name, int, 64, 1, PRIx64, EXPECTED, comment); \
CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment); \
CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment); \
CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment); \
CHECK(test_name, uint, 64, 1, PRIx64, EXPECTED, comment); \
CHECK_POLY(test_name, poly, 8, 8, PRIx8, EXPECTED, comment); \
CHECK_POLY(test_name, poly, 16, 4, PRIx16, EXPECTED, comment); \
CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment); \
\
CHECK(test_name, int, 8, 16, PRIx8, EXPECTED, comment); \
CHECK(test_name, int, 16, 8, PRIx16, EXPECTED, comment); \
CHECK(test_name, int, 32, 4, PRIx32, EXPECTED, comment); \
CHECK(test_name, int, 64, 2, PRIx64, EXPECTED, comment); \
CHECK(test_name, uint, 8, 16, PRIx8, EXPECTED, comment); \
CHECK(test_name, uint, 16, 8, PRIx16, EXPECTED, comment); \
CHECK(test_name, uint, 32, 4, PRIx32, EXPECTED, comment); \
CHECK(test_name, uint, 64, 2, PRIx64, EXPECTED, comment); \
CHECK_POLY(test_name, poly, 8, 16, PRIx8, EXPECTED, comment); \
CHECK_POLY(test_name, poly, 16, 8, PRIx16, EXPECTED, comment); \
CHECK_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment); \
} \
/* Check results against EXPECTED. Operates on all possible vector types. */
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
#define CHECK_RESULTS_NAMED(test_name,EXPECTED,comment) \
{ \
CHECK_RESULTS_NAMED_NO_FP16(test_name, EXPECTED, comment) \
CHECK_FP(test_name, float, 16, 4, PRIx16, EXPECTED, comment); \
CHECK_FP(test_name, float, 16, 8, PRIx16, EXPECTED, comment); \
}
#else
#define CHECK_RESULTS_NAMED(test_name,EXPECTED,comment) \
CHECK_RESULTS_NAMED_NO_FP16(test_name, EXPECTED, comment)
#endif
#define CHECK_RESULTS_NO_FP16(test_name,comment) \
CHECK_RESULTS_NAMED_NO_FP16(test_name, expected, comment)
#define CHECK_RESULTS(test_name,comment) \
CHECK_RESULTS_NAMED(test_name, expected, comment)
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
typedef union {
struct {
int _xxx:24;
unsigned int FZ:1;
unsigned int DN:1;
unsigned int AHP:1;
unsigned int QC:1;
int V:1;
int C:1;
int Z:1;
int N:1;
} b;
unsigned int word;
} _ARM_FPSCR;
#else /* __ORDER_BIG_ENDIAN__ */
typedef union {
struct {
int N:1;
int Z:1;
int C:1;
int V:1;
unsigned int QC:1;
unsigned int AHP:1;
unsigned int DN:1;
unsigned int FZ:1;
int _dnm:24;
} b;
unsigned int word;
} _ARM_FPSCR;
#endif /* __ORDER_BIG_ENDIAN__ */
#define Neon_Cumulative_Sat __read_neon_cumulative_sat()
/* We need a fake dependency to ensure correct ordering of asm
statements to preset the QC flag value, and Neon operators writing
to QC. */
#define Set_Neon_Cumulative_Sat(x, depend) \
__set_neon_cumulative_sat((x), (depend))
#if defined(__aarch64__)
static volatile int __read_neon_cumulative_sat (void) {
_ARM_FPSCR _afpscr_for_qc;
asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc));
return _afpscr_for_qc.b.QC;
}
#define __set_neon_cumulative_sat(x, depend) { \
_ARM_FPSCR _afpscr_for_qc; \
asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc)); \
_afpscr_for_qc.b.QC = x; \
asm volatile ("msr fpsr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \
}
#else
static volatile int __read_neon_cumulative_sat (void) {
_ARM_FPSCR _afpscr_for_qc;
asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc));
return _afpscr_for_qc.b.QC;
}
#define __set_neon_cumulative_sat(x, depend) { \
_ARM_FPSCR _afpscr_for_qc; \
asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc)); \
_afpscr_for_qc.b.QC = x; \
asm volatile ("vmsr fpscr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \
}
#endif
/* Clean output buffers before execution. */
static void clean_results (void)
{
CLEAN(result, int, 8, 8);
CLEAN(result, int, 16, 4);
CLEAN(result, int, 32, 2);
CLEAN(result, int, 64, 1);
CLEAN(result, uint, 8, 8);
CLEAN(result, uint, 16, 4);
CLEAN(result, uint, 32, 2);
CLEAN(result, uint, 64, 1);
CLEAN(result, poly, 8, 8);
CLEAN(result, poly, 16, 4);
#if defined (__ARM_FEATURE_CRYPTO)
CLEAN(result, poly, 64, 1);
#endif
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
CLEAN(result, float, 16, 4);
#endif
CLEAN(result, float, 32, 2);
CLEAN(result, int, 8, 16);
CLEAN(result, int, 16, 8);
CLEAN(result, int, 32, 4);
CLEAN(result, int, 64, 2);
CLEAN(result, uint, 8, 16);
CLEAN(result, uint, 16, 8);
CLEAN(result, uint, 32, 4);
CLEAN(result, uint, 64, 2);
CLEAN(result, poly, 8, 16);
CLEAN(result, poly, 16, 8);
#if defined (__ARM_FEATURE_CRYPTO)
CLEAN(result, poly, 64, 2);
#endif
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
CLEAN(result, float, 16, 8);
#endif
CLEAN(result, float, 32, 4);
AARCH64_ONLY(CLEAN(result, float, 64, 2));
#if defined(__aarch64__)
/* On AArch64, make sure to return DefaultNaN to have the same
results as on AArch32. */
_ARM_FPSCR _afpscr;
asm volatile ("mrs %0,fpcr" : "=r" (_afpscr));
_afpscr.b.DN = 1;
/* On AArch64, make sure to flush to zero by default, as on
AArch32. */
_afpscr.b.FZ = 1;
asm volatile ("msr fpcr,%0" : : "r" (_afpscr));
#endif
}
/* Helpers to declare variables of various types. */
#define DECL_VARIABLE(VAR, T1, W, N) \
VECT_TYPE(T1, W, N) VECT_VAR(VAR, T1, W, N)
#if defined (__ARM_FEATURE_CRYPTO)
#define DECL_VARIABLE_CRYPTO(VAR, T1, W, N) \
DECL_VARIABLE(VAR, T1, W, N)
#else
#define DECL_VARIABLE_CRYPTO(VAR, T1, W, N)
#endif
/* Declare only 64 bits signed variants. */
#define DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR) \
DECL_VARIABLE(VAR, int, 8, 8); \
DECL_VARIABLE(VAR, int, 16, 4); \
DECL_VARIABLE(VAR, int, 32, 2); \
DECL_VARIABLE(VAR, int, 64, 1)
/* Declare only 64 bits unsigned variants. */
#define DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR) \
DECL_VARIABLE(VAR, uint, 8, 8); \
DECL_VARIABLE(VAR, uint, 16, 4); \
DECL_VARIABLE(VAR, uint, 32, 2); \
DECL_VARIABLE(VAR, uint, 64, 1)
/* Declare only 128 bits signed variants. */
#define DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR) \
DECL_VARIABLE(VAR, int, 8, 16); \
DECL_VARIABLE(VAR, int, 16, 8); \
DECL_VARIABLE(VAR, int, 32, 4); \
DECL_VARIABLE(VAR, int, 64, 2)
/* Declare only 128 bits unsigned variants. */
#define DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR) \
DECL_VARIABLE(VAR, uint, 8, 16); \
DECL_VARIABLE(VAR, uint, 16, 8); \
DECL_VARIABLE(VAR, uint, 32, 4); \
DECL_VARIABLE(VAR, uint, 64, 2)
/* Declare all 64 bits variants. */
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
#define DECL_VARIABLE_64BITS_VARIANTS(VAR) \
DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \
DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \
DECL_VARIABLE(VAR, poly, 8, 8); \
DECL_VARIABLE(VAR, poly, 16, 4); \
DECL_VARIABLE_CRYPTO(VAR, poly, 64, 1); \
DECL_VARIABLE(VAR, float, 16, 4); \
DECL_VARIABLE(VAR, float, 32, 2)
#else
#define DECL_VARIABLE_64BITS_VARIANTS(VAR) \
DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \
DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \
DECL_VARIABLE(VAR, poly, 8, 8); \
DECL_VARIABLE(VAR, poly, 16, 4); \
DECL_VARIABLE_CRYPTO(VAR, poly, 64, 1); \
DECL_VARIABLE(VAR, float, 32, 2)
#endif
/* Declare all 128 bits variants. */
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
#define DECL_VARIABLE_128BITS_VARIANTS(VAR) \
DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR); \
DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR); \
DECL_VARIABLE(VAR, poly, 8, 16); \
DECL_VARIABLE(VAR, poly, 16, 8); \
DECL_VARIABLE_CRYPTO(VAR, poly, 64, 2); \
DECL_VARIABLE(VAR, float, 16, 8); \
DECL_VARIABLE(VAR, float, 32, 4); \
AARCH64_ONLY(DECL_VARIABLE(VAR, float, 64, 2))
#else
#define DECL_VARIABLE_128BITS_VARIANTS(VAR) \
DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR); \
DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR); \
DECL_VARIABLE(VAR, poly, 8, 16); \
DECL_VARIABLE(VAR, poly, 16, 8); \
DECL_VARIABLE_CRYPTO(VAR, poly, 64, 2); \
DECL_VARIABLE(VAR, float, 32, 4); \
AARCH64_ONLY(DECL_VARIABLE(VAR, float, 64, 2))
#endif
/* Declare all variants. */
#define DECL_VARIABLE_ALL_VARIANTS(VAR) \
DECL_VARIABLE_64BITS_VARIANTS(VAR); \
DECL_VARIABLE_128BITS_VARIANTS(VAR)
/* Declare all signed variants. */
#define DECL_VARIABLE_SIGNED_VARIANTS(VAR) \
DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \
DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR)
/* Declare all unsigned variants. */
#define DECL_VARIABLE_UNSIGNED_VARIANTS(VAR) \
DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \
DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR)
/* Helpers to initialize vectors. */
#define VDUP(VAR, Q, T1, T2, W, N, V) \
VECT_VAR(VAR, T1, W, N) = vdup##Q##_n_##T2##W(V)
#define VSET_LANE(VAR, Q, T1, T2, W, N, L, V) \
VECT_VAR(VAR, T1, W, N) = vset##Q##_lane_##T2##W(V, \
VECT_VAR(VAR, T1, W, N), \
L)
/* We need to load initial values first, so rely on VLD1. */
#define VLOAD(VAR, BUF, Q, T1, T2, W, N) \
VECT_VAR(VAR, T1, W, N) = vld1##Q##_##T2##W(VECT_VAR(BUF, T1, W, N))
/* Helpers to call macros with 1 constant and 5 variable
arguments. */
#if defined (__ARM_FEATURE_CRYPTO)
#define MACRO_CRYPTO(MACRO, VAR1, VAR2, T1, T2, T3, W, N) \
MACRO(VAR1, VAR2, T1, T2, T3, W, N)
#else
#define MACRO_CRYPTO(MACRO, VAR1, VAR2, T1, T2, T3, W, N)
#endif
#define TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) \
MACRO(VAR, , int, s, 8, 8); \
MACRO(VAR, , int, s, 16, 4); \
MACRO(VAR, , int, s, 32, 2); \
MACRO(VAR, , int, s, 64, 1)
#define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR) \
MACRO(VAR, , uint, u, 8, 8); \
MACRO(VAR, , uint, u, 16, 4); \
MACRO(VAR, , uint, u, 32, 2); \
MACRO(VAR, , uint, u, 64, 1)
#define TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) \
MACRO(VAR, q, int, s, 8, 16); \
MACRO(VAR, q, int, s, 16, 8); \
MACRO(VAR, q, int, s, 32, 4); \
MACRO(VAR, q, int, s, 64, 2)
#define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO,VAR) \
MACRO(VAR, q, uint, u, 8, 16); \
MACRO(VAR, q, uint, u, 16, 8); \
MACRO(VAR, q, uint, u, 32, 4); \
MACRO(VAR, q, uint, u, 64, 2)
#define TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR) \
TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \
TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)
#define TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR) \
TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \
TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)
#define TEST_MACRO_ALL_VARIANTS_1_5(MACRO, VAR) \
TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR); \
TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR)
#define TEST_MACRO_SIGNED_VARIANTS_1_5(MACRO, VAR) \
TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \
TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR)
/* Helpers to call macros with 2 constant and 5 variable
arguments. */
#define TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
MACRO(VAR1, VAR2, , int, s, 8, 8); \
MACRO(VAR1, VAR2, , int, s, 16, 4); \
MACRO(VAR1, VAR2, , int, s, 32, 2); \
MACRO(VAR1, VAR2 , , int, s, 64, 1)
#define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
MACRO(VAR1, VAR2, , uint, u, 8, 8); \
MACRO(VAR1, VAR2, , uint, u, 16, 4); \
MACRO(VAR1, VAR2, , uint, u, 32, 2); \
MACRO(VAR1, VAR2, , uint, u, 64, 1)
#define TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
MACRO(VAR1, VAR2, q, int, s, 8, 16); \
MACRO(VAR1, VAR2, q, int, s, 16, 8); \
MACRO(VAR1, VAR2, q, int, s, 32, 4); \
MACRO(VAR1, VAR2, q, int, s, 64, 2)
#define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
MACRO(VAR1, VAR2, q, uint, u, 8, 16); \
MACRO(VAR1, VAR2, q, uint, u, 16, 8); \
MACRO(VAR1, VAR2, q, uint, u, 32, 4); \
MACRO(VAR1, VAR2, q, uint, u, 64, 2)
#define TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) \
TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
MACRO(VAR1, VAR2, , poly, p, 8, 8); \
MACRO(VAR1, VAR2, , poly, p, 16, 4); \
MACRO_CRYPTO(MACRO, VAR1, VAR2, , poly, p, 64, 1)
#define TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) \
TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
MACRO(VAR1, VAR2, q, poly, p, 8, 16); \
MACRO(VAR1, VAR2, q, poly, p, 16, 8); \
MACRO_CRYPTO(MACRO, VAR1, VAR2, q, poly, p, 64, 2)
#define TEST_MACRO_ALL_VARIANTS_2_5(MACRO, VAR1, VAR2) \
TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2); \
TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2)
#define TEST_MACRO_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \
TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \
TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)
#endif /* _ARM_NEON_REF_H_ */
|
