void FNNAME (INSN_NAME) (void) { /* Basic test: v3=vshl(v1,v2), then store the result. */ #define TEST_VSHL(T3, Q, T1, T2, W, N) \ VECT_VAR(vector_res, T1, W, N) = \ vshl##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \ VECT_VAR(vector_shift, T3, W, N)); \ vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N)) DECL_VARIABLE_ALL_VARIANTS(vector); DECL_VARIABLE_ALL_VARIANTS(vector_res); DECL_VARIABLE_SIGNED_VARIANTS(vector_shift); clean_results (); /* Initialize input "vector" from "buffer". */ TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer); /* Choose init value arbitrarily, will be used as shift amount. */ VDUP(vector_shift, , int, s, 8, 8, 1); VDUP(vector_shift, , int, s, 16, 4, 3); VDUP(vector_shift, , int, s, 32, 2, 8); VDUP(vector_shift, , int, s, 64, 1, 3); VDUP(vector_shift, q, int, s, 8, 16, 5); VDUP(vector_shift, q, int, s, 16, 8, 12); VDUP(vector_shift, q, int, s, 32, 4, 30); VDUP(vector_shift, q, int, s, 64, 2, 63); /* Execute the tests. */ TEST_MACRO_ALL_VARIANTS_1_5(TEST_VSHL, int); CHECK(TEST_MSG, int, 8, 8, PRIx8, expected, ""); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected, ""); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected, ""); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected, ""); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected, ""); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected, ""); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected, ""); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected, ""); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected, ""); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected, ""); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected, ""); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected, ""); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected, ""); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected, ""); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected, ""); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected, ""); /* Test large shift amount (larger or equal to the type width. */ VDUP(vector_shift, , int, s, 8, 8, 8); VDUP(vector_shift, , int, s, 16, 4, 16); VDUP(vector_shift, , int, s, 32, 2, 32); VDUP(vector_shift, , int, s, 64, 1, 64); VDUP(vector_shift, q, int, s, 8, 16, 8); VDUP(vector_shift, q, int, s, 16, 8, 17); VDUP(vector_shift, q, int, s, 32, 4, 33); VDUP(vector_shift, q, int, s, 64, 2, 65); /* Execute the tests. */ TEST_MACRO_ALL_VARIANTS_1_5(TEST_VSHL, int); #define COMMENT1 "(large shift amount)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_large_shift, COMMENT1); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_large_shift, COMMENT1); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_large_shift, COMMENT1); /* Test negative shift amount. */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -1); VDUP(vector_shift, , int, s, 32, 2, -2); VDUP(vector_shift, , int, s, 64, 1, -4); VDUP(vector_shift, q, int, s, 8, 16, -2); VDUP(vector_shift, q, int, s, 16, 8, -5); VDUP(vector_shift, q, int, s, 32, 4, -3); VDUP(vector_shift, q, int, s, 64, 2, -5); /* Execute the tests. */ TEST_MACRO_ALL_VARIANTS_1_5(TEST_VSHL, int); #define COMMENT2 "(negative shift amount)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_negative_shift, COMMENT2); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_negative_shift, COMMENT2); }
void exec_vrshl (void) { /* Basic test: v3=vrshl(v1,v2), then store the result. */ #define TEST_VRSHL(T3, Q, T1, T2, W, N) \ VECT_VAR(vector_res, T1, W, N) = \ vrshl##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \ VECT_VAR(vector_shift, T3, 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 */ DECL_VARIABLE_ALL_VARIANTS(vector); DECL_VARIABLE_ALL_VARIANTS(vector_res); DECL_VARIABLE_SIGNED_VARIANTS(vector_shift); clean_results (); /* Fill input vector with 0, to check behavior on limits */ VDUP(vector, , int, s, 8, 8, 0); VDUP(vector, , int, s, 16, 4, 0); VDUP(vector, , int, s, 32, 2, 0); VDUP(vector, , int, s, 64, 1, 0); VDUP(vector, , uint, u, 8, 8, 0); VDUP(vector, , uint, u, 16, 4, 0); VDUP(vector, , uint, u, 32, 2, 0); VDUP(vector, , uint, u, 64, 1, 0); VDUP(vector, q, int, s, 8, 16, 0); VDUP(vector, q, int, s, 16, 8, 0); VDUP(vector, q, int, s, 32, 4, 0); VDUP(vector, q, int, s, 64, 2, 0); VDUP(vector, q, uint, u, 8, 16, 0); VDUP(vector, q, uint, u, 16, 8, 0); VDUP(vector, q, uint, u, 32, 4, 0); VDUP(vector, q, uint, u, 64, 2, 0); /* Choose init value arbitrarily, will be used as shift amount */ /* Use values equal to one-less-than the type width to check behaviour on limits */ VDUP(vector_shift, , int, s, 8, 8, 7); VDUP(vector_shift, , int, s, 16, 4, 15); VDUP(vector_shift, , int, s, 32, 2, 31); VDUP(vector_shift, , int, s, 64, 1, 63); VDUP(vector_shift, q, int, s, 8, 16, 7); VDUP(vector_shift, q, int, s, 16, 8, 15); VDUP(vector_shift, q, int, s, 32, 4, 31); VDUP(vector_shift, q, int, s, 64, 2, 63); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (with input = 0)"); /* Use negative shift amounts */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -2); VDUP(vector_shift, , int, s, 32, 2, -3); VDUP(vector_shift, , int, s, 64, 1, -4); VDUP(vector_shift, q, int, s, 8, 16, -7); VDUP(vector_shift, q, int, s, 16, 8, -11); VDUP(vector_shift, q, int, s, 32, 4, -13); VDUP(vector_shift, q, int, s, 64, 2, -20); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (input 0 and negative shift amount)"); /* Test again, with predefined input values */ TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer); /* Choose init value arbitrarily, will be used as shift amount */ VDUP(vector_shift, , int, s, 8, 8, 1); VDUP(vector_shift, , int, s, 16, 4, 3); VDUP(vector_shift, , int, s, 32, 2, 8); VDUP(vector_shift, , int, s, 64, 1, -3); VDUP(vector_shift, q, int, s, 8, 16, 10); VDUP(vector_shift, q, int, s, 16, 8, 12); VDUP(vector_shift, q, int, s, 32, 4, 32); VDUP(vector_shift, q, int, s, 64, 2, 63); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex (TEST_MSG); /* Use negative shift amounts */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -2); VDUP(vector_shift, , int, s, 32, 2, -3); VDUP(vector_shift, , int, s, 64, 1, -4); VDUP(vector_shift, q, int, s, 8, 16, -7); VDUP(vector_shift, q, int, s, 16, 8, -11); VDUP(vector_shift, q, int, s, 32, 4, -13); VDUP(vector_shift, q, int, s, 64, 2, -20); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (negative shift amount)"); /* Fill input vector with max value, to check behavior on limits */ VDUP(vector, , int, s, 8, 8, 0x7F); VDUP(vector, , int, s, 16, 4, 0x7FFF); VDUP(vector, , int, s, 32, 2, 0x7FFFFFFF); VDUP(vector, , int, s, 64, 1, 0x7FFFFFFFFFFFFFFFLL); VDUP(vector, , uint, u, 8, 8, 0xFF); VDUP(vector, , uint, u, 16, 4, 0xFFFF); VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF); VDUP(vector, , uint, u, 64, 1, 0xFFFFFFFFFFFFFFFFULL); VDUP(vector, q, int, s, 8, 16, 0x7F); VDUP(vector, q, int, s, 16, 8, 0x7FFF); VDUP(vector, q, int, s, 32, 4, 0x7FFFFFFF); VDUP(vector, q, int, s, 64, 2, 0x7FFFFFFFFFFFFFFFLL); VDUP(vector, q, uint, u, 8, 16, 0xFF); VDUP(vector, q, uint, u, 16, 8, 0xFFFF); VDUP(vector, q, uint, u, 32, 4, 0xFFFFFFFF); VDUP(vector, q, uint, u, 64, 2, 0xFFFFFFFFFFFFFFFFULL); /* Use -1 shift amount to check overflow with round_const */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -1); VDUP(vector_shift, , int, s, 32, 2, -1); VDUP(vector_shift, , int, s, 64, 1, -1); VDUP(vector_shift, q, int, s, 8, 16, -1); VDUP(vector_shift, q, int, s, 16, 8, -1); VDUP(vector_shift, q, int, s, 32, 4, -1); VDUP(vector_shift, q, int, s, 64, 2, -1); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (checking round_const overflow: shift by -1)"); /* Use -3 shift amount to check overflow with round_const */ VDUP(vector_shift, , int, s, 8, 8, -3); VDUP(vector_shift, , int, s, 16, 4, -3); VDUP(vector_shift, , int, s, 32, 2, -3); VDUP(vector_shift, , int, s, 64, 1, -3); VDUP(vector_shift, q, int, s, 8, 16, -3); VDUP(vector_shift, q, int, s, 16, 8, -3); VDUP(vector_shift, q, int, s, 32, 4, -3); VDUP(vector_shift, q, int, s, 64, 2, -3); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (checking round_const overflow: shift by -3)"); /* Use negative shift amount as large as input vector width */ VDUP(vector_shift, , int, s, 8, 8, -8); VDUP(vector_shift, , int, s, 16, 4, -16); VDUP(vector_shift, , int, s, 32, 2, -32); VDUP(vector_shift, , int, s, 64, 1, -64); VDUP(vector_shift, q, int, s, 8, 16, -8); VDUP(vector_shift, q, int, s, 16, 8, -16); VDUP(vector_shift, q, int, s, 32, 4, -32); VDUP(vector_shift, q, int, s, 64, 2, -64); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (checking negative shift amount as large as input vector width)"); /* Test large shift amount */ VDUP(vector_shift, , int, s, 8, 8, 10); VDUP(vector_shift, , int, s, 16, 4, 20); VDUP(vector_shift, , int, s, 32, 2, 33); VDUP(vector_shift, , int, s, 64, 1, 65); VDUP(vector_shift, q, int, s, 8, 16, 9); VDUP(vector_shift, q, int, s, 16, 8, 16); VDUP(vector_shift, q, int, s, 32, 4, 32); VDUP(vector_shift, q, int, s, 64, 2, 64); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (large shift amount)"); /* Test large negative shift amount */ VDUP(vector_shift, , int, s, 8, 8, -10); VDUP(vector_shift, , int, s, 16, 4, -20); VDUP(vector_shift, , int, s, 32, 2, -33); VDUP(vector_shift, , int, s, 64, 1, -65); VDUP(vector_shift, q, int, s, 8, 16, -9); VDUP(vector_shift, q, int, s, 16, 8, -16); VDUP(vector_shift, q, int, s, 32, 4, -32); VDUP(vector_shift, q, int, s, 64, 2, -64); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); dump_results_hex2 (TEST_MSG, " (large negative shift amount)"); }
void exec_vrshl (void) { /* Basic test: v3=vrshl(v1,v2), then store the result. */ #define TEST_VRSHL(T3, Q, T1, T2, W, N) \ VECT_VAR(vector_res, T1, W, N) = \ vrshl##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \ VECT_VAR(vector_shift, T3, W, N)); \ vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N)) DECL_VARIABLE_ALL_VARIANTS(vector); DECL_VARIABLE_ALL_VARIANTS(vector_res); DECL_VARIABLE_SIGNED_VARIANTS(vector_shift); clean_results (); /* Fill input vector with 0, to check behavior on limits. */ VDUP(vector, , int, s, 8, 8, 0); VDUP(vector, , int, s, 16, 4, 0); VDUP(vector, , int, s, 32, 2, 0); VDUP(vector, , int, s, 64, 1, 0); VDUP(vector, , uint, u, 8, 8, 0); VDUP(vector, , uint, u, 16, 4, 0); VDUP(vector, , uint, u, 32, 2, 0); VDUP(vector, , uint, u, 64, 1, 0); VDUP(vector, q, int, s, 8, 16, 0); VDUP(vector, q, int, s, 16, 8, 0); VDUP(vector, q, int, s, 32, 4, 0); VDUP(vector, q, int, s, 64, 2, 0); VDUP(vector, q, uint, u, 8, 16, 0); VDUP(vector, q, uint, u, 16, 8, 0); VDUP(vector, q, uint, u, 32, 4, 0); VDUP(vector, q, uint, u, 64, 2, 0); /* Choose init value arbitrarily, will be used as shift amount. */ /* Use values equal to one-less-than the type width to check behaviour on limits. */ VDUP(vector_shift, , int, s, 8, 8, 7); VDUP(vector_shift, , int, s, 16, 4, 15); VDUP(vector_shift, , int, s, 32, 2, 31); VDUP(vector_shift, , int, s, 64, 1, 63); VDUP(vector_shift, q, int, s, 8, 16, 7); VDUP(vector_shift, q, int, s, 16, 8, 15); VDUP(vector_shift, q, int, s, 32, 4, 31); VDUP(vector_shift, q, int, s, 64, 2, 63); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #define CMT " (with input = 0)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_0, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_0, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_0, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_0, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_0, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_0, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_0, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_0, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_0, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_0, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_0, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_0, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_0, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_0, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_0, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_0, CMT); /* Use negative shift amounts. */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -2); VDUP(vector_shift, , int, s, 32, 2, -3); VDUP(vector_shift, , int, s, 64, 1, -4); VDUP(vector_shift, q, int, s, 8, 16, -7); VDUP(vector_shift, q, int, s, 16, 8, -11); VDUP(vector_shift, q, int, s, 32, 4, -13); VDUP(vector_shift, q, int, s, 64, 2, -20); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (input 0 and negative shift amount)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_0_sh_neg, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_0_sh_neg, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_0_sh_neg, CMT); /* Test again, with predefined input values. */ TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer); /* Choose init value arbitrarily, will be used as shift amount. */ VDUP(vector_shift, , int, s, 8, 8, 1); VDUP(vector_shift, , int, s, 16, 4, 3); VDUP(vector_shift, , int, s, 32, 2, 8); VDUP(vector_shift, , int, s, 64, 1, -3); VDUP(vector_shift, q, int, s, 8, 16, 10); VDUP(vector_shift, q, int, s, 16, 8, 12); VDUP(vector_shift, q, int, s, 32, 4, 32); VDUP(vector_shift, q, int, s, 64, 2, 63); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT "" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected, CMT); /* Use negative shift amounts. */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -2); VDUP(vector_shift, , int, s, 32, 2, -3); VDUP(vector_shift, , int, s, 64, 1, -4); VDUP(vector_shift, q, int, s, 8, 16, -7); VDUP(vector_shift, q, int, s, 16, 8, -11); VDUP(vector_shift, q, int, s, 32, 4, -13); VDUP(vector_shift, q, int, s, 64, 2, -20); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (negative shift amount)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_sh_neg, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_sh_neg, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_sh_neg, CMT); /* Fill input vector with max value, to check behavior on limits. */ VDUP(vector, , int, s, 8, 8, 0x7F); VDUP(vector, , int, s, 16, 4, 0x7FFF); VDUP(vector, , int, s, 32, 2, 0x7FFFFFFF); VDUP(vector, , int, s, 64, 1, 0x7FFFFFFFFFFFFFFFLL); VDUP(vector, , uint, u, 8, 8, 0xFF); VDUP(vector, , uint, u, 16, 4, 0xFFFF); VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF); VDUP(vector, , uint, u, 64, 1, 0xFFFFFFFFFFFFFFFFULL); VDUP(vector, q, int, s, 8, 16, 0x7F); VDUP(vector, q, int, s, 16, 8, 0x7FFF); VDUP(vector, q, int, s, 32, 4, 0x7FFFFFFF); VDUP(vector, q, int, s, 64, 2, 0x7FFFFFFFFFFFFFFFLL); VDUP(vector, q, uint, u, 8, 16, 0xFF); VDUP(vector, q, uint, u, 16, 8, 0xFFFF); VDUP(vector, q, uint, u, 32, 4, 0xFFFFFFFF); VDUP(vector, q, uint, u, 64, 2, 0xFFFFFFFFFFFFFFFFULL); /* Use -1 shift amount to check overflow with round_const. */ VDUP(vector_shift, , int, s, 8, 8, -1); VDUP(vector_shift, , int, s, 16, 4, -1); VDUP(vector_shift, , int, s, 32, 2, -1); VDUP(vector_shift, , int, s, 64, 1, -1); VDUP(vector_shift, q, int, s, 8, 16, -1); VDUP(vector_shift, q, int, s, 16, 8, -1); VDUP(vector_shift, q, int, s, 32, 4, -1); VDUP(vector_shift, q, int, s, 64, 2, -1); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (max input, shift by -1)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_sh_minus1, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_sh_minus1, CMT); /* Use -3 shift amount to check overflow with round_const. */ VDUP(vector_shift, , int, s, 8, 8, -3); VDUP(vector_shift, , int, s, 16, 4, -3); VDUP(vector_shift, , int, s, 32, 2, -3); VDUP(vector_shift, , int, s, 64, 1, -3); VDUP(vector_shift, q, int, s, 8, 16, -3); VDUP(vector_shift, q, int, s, 16, 8, -3); VDUP(vector_shift, q, int, s, 32, 4, -3); VDUP(vector_shift, q, int, s, 64, 2, -3); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (check rounding constant: max input, shift by -3)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_sh_minus3, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_sh_minus3, CMT); /* Use negative shift amount as large as input vector width. */ VDUP(vector_shift, , int, s, 8, 8, -8); VDUP(vector_shift, , int, s, 16, 4, -16); VDUP(vector_shift, , int, s, 32, 2, -32); VDUP(vector_shift, , int, s, 64, 1, -64); VDUP(vector_shift, q, int, s, 8, 16, -8); VDUP(vector_shift, q, int, s, 16, 8, -16); VDUP(vector_shift, q, int, s, 32, 4, -32); VDUP(vector_shift, q, int, s, 64, 2, -64); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (max input, right shift by vector width)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_sh_minus_width, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_sh_minus_width, CMT); /* Test large shift amount. */ VDUP(vector_shift, , int, s, 8, 8, 10); VDUP(vector_shift, , int, s, 16, 4, 20); VDUP(vector_shift, , int, s, 32, 2, 33); VDUP(vector_shift, , int, s, 64, 1, 65); VDUP(vector_shift, q, int, s, 8, 16, 9); VDUP(vector_shift, q, int, s, 16, 8, 16); VDUP(vector_shift, q, int, s, 32, 4, 32); VDUP(vector_shift, q, int, s, 64, 2, 64); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (max input, large shift amount)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_sh_large, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_sh_large, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_sh_large, CMT); /* Test large negative shift amount. */ VDUP(vector_shift, , int, s, 8, 8, -10); VDUP(vector_shift, , int, s, 16, 4, -20); VDUP(vector_shift, , int, s, 32, 2, -33); VDUP(vector_shift, , int, s, 64, 1, -65); VDUP(vector_shift, q, int, s, 8, 16, -9); VDUP(vector_shift, q, int, s, 16, 8, -16); VDUP(vector_shift, q, int, s, 32, 4, -32); VDUP(vector_shift, q, int, s, 64, 2, -64); TEST_MACRO_ALL_VARIANTS_1_5(TEST_VRSHL, int); #undef CMT #define CMT " (max input, large negative shift amount)" CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_sh_large_neg, CMT); CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_sh_large_neg, CMT); }