void exec_vdup_lane (void)
{
/* Basic test: vec1=vdup_lane(vec2, lane), then store the result. */
#define TEST_VDUP_LANE(Q, T1, T2, W, N, N2, L) \
VECT_VAR(vector_res, T1, W, N) = \
vdup##Q##_lane_##T2##W(VECT_VAR(vector, T1, W, N2), L); \
vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
/* Input vector can only have 64 bits. */
DECL_VARIABLE_64BITS_VARIANTS(vector);
DECL_VARIABLE_ALL_VARIANTS(vector_res);
clean_results ();
TEST_MACRO_64BITS_VARIANTS_2_5(VLOAD, vector, buffer);
#if defined (FP16_SUPPORTED)
VLOAD(vector, buffer, , float, f, 16, 4);
#endif
VLOAD(vector, buffer, , float, f, 32, 2);
/* Choose lane arbitrarily. */
TEST_VDUP_LANE(, int, s, 8, 8, 8, 1);
TEST_VDUP_LANE(, int, s, 16, 4, 4, 2);
TEST_VDUP_LANE(, int, s, 32, 2, 2, 1);
TEST_VDUP_LANE(, int, s, 64, 1, 1, 0);
TEST_VDUP_LANE(, uint, u, 8, 8, 8, 7);
TEST_VDUP_LANE(, uint, u, 16, 4, 4, 3);
TEST_VDUP_LANE(, uint, u, 32, 2, 2, 1);
TEST_VDUP_LANE(, uint, u, 64, 1, 1, 0);
TEST_VDUP_LANE(, poly, p, 8, 8, 8, 7);
TEST_VDUP_LANE(, poly, p, 16, 4, 4, 3);
#if defined (FP16_SUPPORTED)
TEST_VDUP_LANE(, float, f, 16, 4, 4, 3);
#endif
TEST_VDUP_LANE(, float, f, 32, 2, 2, 1);
TEST_VDUP_LANE(q, int, s, 8, 16, 8, 2);
TEST_VDUP_LANE(q, int, s, 16, 8, 4, 3);
TEST_VDUP_LANE(q, int, s, 32, 4, 2, 1);
TEST_VDUP_LANE(q, int, s, 64, 2, 1, 0);
TEST_VDUP_LANE(q, uint, u, 8, 16, 8, 5);
TEST_VDUP_LANE(q, uint, u, 16, 8, 4, 1);
TEST_VDUP_LANE(q, uint, u, 32, 4, 2, 0);
TEST_VDUP_LANE(q, uint, u, 64, 2, 1, 0);
TEST_VDUP_LANE(q, poly, p, 8, 16, 8, 5);
TEST_VDUP_LANE(q, poly, p, 16, 8, 4, 1);
#if defined (FP16_SUPPORTED)
TEST_VDUP_LANE(q, float, f, 16, 8, 4, 3);
#endif
TEST_VDUP_LANE(q, float, f, 32, 4, 2, 1);
#if defined (FP16_SUPPORTED)
CHECK_RESULTS (TEST_MSG, "");
#else
CHECK_RESULTS_NO_FP16 (TEST_MSG, "");
#endif
}
void exec_vld1 (void)
{
/* Basic test vec=vld1(buffer); then store vec: vst1(result, vector). */
/* This test actually tests vdl1 and vst1 at the same time. */
#define TEST_VLD1(VAR, BUF, Q, T1, T2, W, N) \
VECT_VAR(VAR, T1, W, N) = vld1##Q##_##T2##W(VECT_VAR(BUF, T1, W, N)); \
vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(VAR, T1, W, N))
DECL_VARIABLE_ALL_VARIANTS(vector);
clean_results ();
TEST_MACRO_ALL_VARIANTS_2_5(TEST_VLD1, vector, buffer);
#if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
TEST_VLD1(vector, buffer, , float, f, 16, 4);
TEST_VLD1(vector, buffer, q, float, f, 16, 8);
#endif
TEST_VLD1(vector, buffer, , float, f, 32, 2);
TEST_VLD1(vector, buffer, q, float, f, 32, 4);
CHECK_RESULTS (TEST_MSG, "");
}
void exec_vext (void)
{
/* vector_res = vext(vector1,vector2,offset), then store the result. */
#define TEST_VEXT(Q, T1, T2, W, N, V) \
VECT_VAR(vector_res, T1, W, N) = \
vext##Q##_##T2##W(VECT_VAR(vector1, T1, W, N), \
VECT_VAR(vector2, T1, W, N), \
V); \
vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
DECL_VARIABLE_ALL_VARIANTS(vector1);
DECL_VARIABLE_ALL_VARIANTS(vector2);
DECL_VARIABLE_ALL_VARIANTS(vector_res);
clean_results ();
TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector1, buffer);
VLOAD(vector1, buffer, , float, f, 32, 2);
VLOAD(vector1, buffer, q, float, f, 32, 4);
/* Choose arbitrary initialization values. */
VDUP(vector2, , int, s, 8, 8, 0x11);
VDUP(vector2, , int, s, 16, 4, 0x22);
VDUP(vector2, , int, s, 32, 2, 0x33);
VDUP(vector2, , int, s, 64, 1, 0x44);
VDUP(vector2, , uint, u, 8, 8, 0x55);
VDUP(vector2, , uint, u, 16, 4, 0x66);
VDUP(vector2, , uint, u, 32, 2, 0x77);
VDUP(vector2, , uint, u, 64, 1, 0x88);
VDUP(vector2, , poly, p, 8, 8, 0x55);
VDUP(vector2, , poly, p, 16, 4, 0x66);
VDUP(vector2, , float, f, 32, 2, 33.6f);
VDUP(vector2, q, int, s, 8, 16, 0x11);
VDUP(vector2, q, int, s, 16, 8, 0x22);
VDUP(vector2, q, int, s, 32, 4, 0x33);
VDUP(vector2, q, int, s, 64, 2, 0x44);
VDUP(vector2, q, uint, u, 8, 16, 0x55);
VDUP(vector2, q, uint, u, 16, 8, 0x66);
VDUP(vector2, q, uint, u, 32, 4, 0x77);
VDUP(vector2, q, uint, u, 64, 2, 0x88);
VDUP(vector2, q, poly, p, 8, 16, 0x55);
VDUP(vector2, q, poly, p, 16, 8, 0x66);
VDUP(vector2, q, float, f, 32, 4, 33.2f);
/* Choose arbitrary extract offsets. */
TEST_VEXT(, int, s, 8, 8, 7);
TEST_VEXT(, int, s, 16, 4, 3);
TEST_VEXT(, int, s, 32, 2, 1);
TEST_VEXT(, int, s, 64, 1, 0);
TEST_VEXT(, uint, u, 8, 8, 6);
TEST_VEXT(, uint, u, 16, 4, 2);
TEST_VEXT(, uint, u, 32, 2, 1);
TEST_VEXT(, uint, u, 64, 1, 0);
TEST_VEXT(, poly, p, 8, 8, 6);
TEST_VEXT(, poly, p, 16, 4, 2);
TEST_VEXT(, float, f, 32, 2, 1);
TEST_VEXT(q, int, s, 8, 16, 14);
TEST_VEXT(q, int, s, 16, 8, 7);
TEST_VEXT(q, int, s, 32, 4, 3);
TEST_VEXT(q, int, s, 64, 2, 1);
TEST_VEXT(q, uint, u, 8, 16, 12);
TEST_VEXT(q, uint, u, 16, 8, 6);
TEST_VEXT(q, uint, u, 32, 4, 3);
TEST_VEXT(q, uint, u, 64, 2, 1);
TEST_VEXT(q, poly, p, 8, 16, 12);
TEST_VEXT(q, poly, p, 16, 8, 6);
TEST_VEXT(q, float, f, 32, 4, 3);
CHECK_RESULTS (TEST_MSG, "");
}
void exec_vaba (void)
{
/* Basic test: v4=vaba(v1,v2,v3), then store the result. */
#define TEST_VABA(Q, T1, T2, W, N) \
VECT_VAR(vector_res, T1, W, N) = \
vaba##Q##_##T2##W(VECT_VAR(vector1, T1, W, N), \
VECT_VAR(vector2, T1, W, N), \
VECT_VAR(vector3, T1, W, N)); \
vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
#define DECL_VABA_VAR(VAR) \
DECL_VARIABLE(VAR, int, 8, 8); \
DECL_VARIABLE(VAR, int, 16, 4); \
DECL_VARIABLE(VAR, int, 32, 2); \
DECL_VARIABLE(VAR, uint, 8, 8); \
DECL_VARIABLE(VAR, uint, 16, 4); \
DECL_VARIABLE(VAR, uint, 32, 2); \
DECL_VARIABLE(VAR, int, 8, 16); \
DECL_VARIABLE(VAR, int, 16, 8); \
DECL_VARIABLE(VAR, int, 32, 4); \
DECL_VARIABLE(VAR, uint, 8, 16); \
DECL_VARIABLE(VAR, uint, 16, 8); \
DECL_VARIABLE(VAR, uint, 32, 4)
DECL_VABA_VAR(vector1);
DECL_VABA_VAR(vector2);
DECL_VABA_VAR(vector3);
DECL_VABA_VAR(vector_res);
clean_results ();
/* Initialize input "vector1" from "buffer". */
VLOAD(vector1, buffer, , int, s, 8, 8);
VLOAD(vector1, buffer, , int, s, 16, 4);
VLOAD(vector1, buffer, , int, s, 32, 2);
VLOAD(vector1, buffer, , uint, u, 8, 8);
VLOAD(vector1, buffer, , uint, u, 16, 4);
VLOAD(vector1, buffer, , uint, u, 32, 2);
VLOAD(vector1, buffer, q, int, s, 8, 16);
VLOAD(vector1, buffer, q, int, s, 16, 8);
VLOAD(vector1, buffer, q, int, s, 32, 4);
VLOAD(vector1, buffer, q, uint, u, 8, 16);
VLOAD(vector1, buffer, q, uint, u, 16, 8);
VLOAD(vector1, buffer, q, uint, u, 32, 4);
/* Choose init value arbitrarily. */
VDUP(vector2, , int, s, 8, 8, 1);
VDUP(vector2, , int, s, 16, 4, -13);
VDUP(vector2, , int, s, 32, 2, 8);
VDUP(vector2, , uint, u, 8, 8, 1);
VDUP(vector2, , uint, u, 16, 4, 13);
VDUP(vector2, , uint, u, 32, 2, 8);
VDUP(vector2, q, int, s, 8, 16, 10);
VDUP(vector2, q, int, s, 16, 8, -12);
VDUP(vector2, q, int, s, 32, 4, 32);
VDUP(vector2, q, uint, u, 8, 16, 10);
VDUP(vector2, q, uint, u, 16, 8, 12);
VDUP(vector2, q, uint, u, 32, 4, 32);
/* Choose init value arbitrarily. */
VDUP(vector3, , int, s, 8, 8, -5);
VDUP(vector3, , int, s, 16, 4, 25);
VDUP(vector3, , int, s, 32, 2, -40);
VDUP(vector3, , uint, u, 8, 8, 100);
VDUP(vector3, , uint, u, 16, 4, 2340);
VDUP(vector3, , uint, u, 32, 2, 0xffffffff);
VDUP(vector3, q, int, s, 8, 16, -100);
VDUP(vector3, q, int, s, 16, 8, -3000);
VDUP(vector3, q, int, s, 32, 4, 10000);
VDUP(vector3, q, uint, u, 8, 16, 2);
VDUP(vector3, q, uint, u, 16, 8, 3);
VDUP(vector3, q, uint, u, 32, 4, 4);
/* Execute the tests. */
TEST_VABA(, int, s, 8, 8);
TEST_VABA(, int, s, 16, 4);
TEST_VABA(, int, s, 32, 2);
TEST_VABA(, uint, u, 8, 8);
TEST_VABA(, uint, u, 16, 4);
TEST_VABA(, uint, u, 32, 2);
TEST_VABA(q, int, s, 8, 16);
TEST_VABA(q, int, s, 16, 8);
TEST_VABA(q, int, s, 32, 4);
TEST_VABA(q, uint, u, 8, 16);
TEST_VABA(q, uint, u, 16, 8);
TEST_VABA(q, uint, u, 32, 4);
CHECK_RESULTS (TEST_MSG, "");
}