void exec_vrecpe(void) { int i; /* Basic test: y=vrecpe(x), then store the result. */ #define TEST_VRECPE(Q, T1, T2, W, N) \ VECT_VAR(vector_res, T1, W, N) = \ vrecpe##Q##_##T2##W(VECT_VAR(vector, T1, W, N)); \ vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), \ VECT_VAR(vector_res, T1, W, N)) /* No need for 64 bits variants. */ DECL_VARIABLE(vector, uint, 32, 2); DECL_VARIABLE(vector, uint, 32, 4); DECL_VARIABLE(vector, float, 32, 2); DECL_VARIABLE(vector, float, 32, 4); DECL_VARIABLE(vector_res, uint, 32, 2); DECL_VARIABLE(vector_res, uint, 32, 4); DECL_VARIABLE(vector_res, float, 32, 2); DECL_VARIABLE(vector_res, float, 32, 4); clean_results (); /* Choose init value arbitrarily, positive. */ VDUP(vector, , uint, u, 32, 2, 0x12345678); VDUP(vector, , float, f, 32, 2, 1.9f); VDUP(vector, q, uint, u, 32, 4, 0xABCDEF10); VDUP(vector, q, float, f, 32, 4, 125.0f); /* Apply the operator. */ TEST_VRECPE(, uint, u, 32, 2); TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, uint, u, 32, 4); TEST_VRECPE(q, float, f, 32, 4); #define CMT " (positive input)" CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_positive, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_positive, CMT); CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected_positive, CMT); CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_positive, CMT); /* Choose init value arbitrarily,negative. */ VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF); VDUP(vector, , float, f, 32, 2, -10.0f); VDUP(vector, q, uint, u, 32, 4, 0x89081234); VDUP(vector, q, float, f, 32, 4, -125.0f); /* Apply the operator. */ TEST_VRECPE(, uint, u, 32, 2); TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, uint, u, 32, 4); TEST_VRECPE(q, float, f, 32, 4); #undef CMT #define CMT " (negative input)" CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_negative, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_negative, CMT); CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected_negative, CMT); CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_negative, CMT); /* Test FP variants with special input values (NaN, infinity). */ VDUP(vector, , float, f, 32, 2, NAN); VDUP(vector, q, float, f, 32, 4, HUGE_VALF); /* Apply the operator. */ TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, float, f, 32, 4); #undef CMT #define CMT " FP special (NaN, infinity)" CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected_fp1, CMT); CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_fp1, CMT); /* Test FP variants with special input values (zero, large value). */ VDUP(vector, , float, f, 32, 2, 0.0f); VDUP(vector, q, float, f, 32, 4, 8.97229e37f /*9.0e37f*/); /* Apply the operator. */ TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, float, f, 32, 4); #undef CMT #define CMT " FP special (zero, large value)" CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected_fp2, CMT); CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_fp2, CMT); /* Test FP variants with special input values (-0, -infinity). */ VDUP(vector, , float, f, 32, 2, -0.0f); VDUP(vector, q, float, f, 32, 4, -HUGE_VALF); /* Apply the operator. */ TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, float, f, 32, 4); #undef CMT #define CMT " FP special (-0, -infinity)" CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected_fp3, CMT); CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_fp3, CMT); /* Test FP variants with special input values (large negative value). */ VDUP(vector, , float, f, 32, 2, -9.0e37f); /* Apply the operator. */ TEST_VRECPE(, float, f, 32, 2); #undef CMT #define CMT " FP special (large negative value)" CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected_fp4, CMT); }
void exec_vrecpe(void) { int i; /* Basic test: y=vrecpe(x), then store the result. */ #define TEST_VRECPE(Q, T1, T2, W, N) \ VECT_VAR(vector_res, T1, W, N) = \ vrecpe##Q##_##T2##W(VECT_VAR(vector, T1, W, N)); \ vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), \ VECT_VAR(vector_res, T1, W, N)) /* With ARM RVCT, we need to declare variables before any executable statement */ /* No need for 64 bits variants */ DECL_VARIABLE(vector, uint, 32, 2); DECL_VARIABLE(vector, uint, 32, 4); DECL_VARIABLE(vector, float, 32, 2); DECL_VARIABLE(vector, float, 32, 4); DECL_VARIABLE(vector_res, uint, 32, 2); DECL_VARIABLE(vector_res, uint, 32, 4); DECL_VARIABLE(vector_res, float, 32, 2); DECL_VARIABLE(vector_res, float, 32, 4); clean_results (); /* Choose init value arbitrarily */ VDUP(vector, , uint, u, 32, 2, 0x12345678); VDUP(vector, , float, f, 32, 2, 1.9f); VDUP(vector, q, uint, u, 32, 4, 0xABCDEF10); VDUP(vector, q, float, f, 32, 4, 125.0f); /* Apply the operator */ TEST_VRECPE(, uint, u, 32, 2); TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, uint, u, 32, 4); TEST_VRECPE(q, float, f, 32, 4); fprintf (ref_file, "\n%s %s output:\n", TEST_MSG, " (positive input)"); DUMP(TEST_MSG, uint, 32, 2, PRIx32); DUMP(TEST_MSG, uint, 32, 4, PRIx32); DUMP_FP(TEST_MSG, float, 32, 2, PRIx32); DUMP_FP(TEST_MSG, float, 32, 4, PRIx32); /* Choose init value arbitrarily */ VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF); VDUP(vector, , float, f, 32, 2, -10.0f); VDUP(vector, q, uint, u, 32, 4, 0x89081234); VDUP(vector, q, float, f, 32, 4, -125.0f); /* Apply the operator */ TEST_VRECPE(, uint, u, 32, 2); TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, uint, u, 32, 4); TEST_VRECPE(q, float, f, 32, 4); fprintf (ref_file, "\n%s %s output:\n", TEST_MSG, " (negative input)"); DUMP(TEST_MSG, uint, 32, 2, PRIx32); DUMP(TEST_MSG, uint, 32, 4, PRIx32); DUMP_FP(TEST_MSG, float, 32, 2, PRIx32); DUMP_FP(TEST_MSG, float, 32, 4, PRIx32); /* Test FP variants with special input values (NaN, infinity) */ VDUP(vector, , float, f, 32, 2, NAN); VDUP(vector, q, float, f, 32, 4, HUGE_VALF); /* Apply the operator */ TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, float, f, 32, 4); fprintf (ref_file, "\n%s %s output:\n", TEST_MSG, " FP special (NaN, infinity)"); DUMP_FP(TEST_MSG, float, 32, 2, PRIx32); DUMP_FP(TEST_MSG, float, 32, 4, PRIx32); /* Test FP variants with special input values (zero, large value) */ VDUP(vector, , float, f, 32, 2, 0.0f); VDUP(vector, q, float, f, 32, 4, 9.0e37f); /* Apply the operator */ TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, float, f, 32, 4); fprintf (ref_file, "\n%s %s output:\n", TEST_MSG, " FP special (zero, large value)"); DUMP_FP(TEST_MSG, float, 32, 2, PRIx32); DUMP_FP(TEST_MSG, float, 32, 4, PRIx32); /* Test FP variants with special input values (-0, -infinity) */ VDUP(vector, , float, f, 32, 2, -0.0f); VDUP(vector, q, float, f, 32, 4, -HUGE_VALF); /* Apply the operator */ TEST_VRECPE(, float, f, 32, 2); TEST_VRECPE(q, float, f, 32, 4); fprintf (ref_file, "\n%s %s output:\n", TEST_MSG, " FP special (-0, -infinity)"); DUMP_FP(TEST_MSG, float, 32, 2, PRIx32); DUMP_FP(TEST_MSG, float, 32, 4, PRIx32); /* Test FP variants with special input values (large negative value) */ VDUP(vector, , float, f, 32, 2, -9.0e37f); /* Apply the operator */ TEST_VRECPE(, float, f, 32, 2); fprintf (ref_file, "\n%s %s output:\n", TEST_MSG, " FP special (large negative value)"); DUMP_FP(TEST_MSG, float, 32, 2, PRIx32); }