GCC maintainers: The patch adds test cases for the __builtin_vec_init* and __builtin_vec_set* built-ins.
The patch has been tested on Power 10 with no regressions. Please let me know if this patch is acceptable for mainline. Thanks. Carl ------------------------------------------------------------ rs6000, add test cases for __builtin_vec_init* and __builtin_vec_set* Add test cases for the following built-ins: __builtin_vec_init_v1ti __builtin_vec_init_v2df __builtin_vec_init_v2di __builtin_vec_set_v1ti __builtin_vec_set_v2df __builtin_vec_set_v2di Note, the above built-ins are documented in extend.texi. gcc/testsuite/ChangeLog: * gcc.target/powerpc/vsx-builtin-21.c: New test file. --- .../gcc.target/powerpc/vsx-builtin-21.c | 181 ++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-21.c diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-21.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-21.c new file mode 100644 index 00000000000..b7e1201f37e --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-21.c @@ -0,0 +1,181 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx" } */ + +/* This test should run the same on any target that supports vsx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#define DEBUG 0 + +#include <altivec.h> + +#if DEBUG +#include <stdio.h> +#include <stdlib.h> + +void print_i128 (__int128_t val) +{ + printf(" %lld %llu (0x%llx %llx)", + (signed long long)(val >> 64), + (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF), + (unsigned long long)(val >> 64), + (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF)); +} +#endif + +void abort (void); + +void test_vec_init_v1ti (__int128_t ti_arg, + vector __int128_t v1ti_expected_result) +{ + vector __int128_t v1ti_result; + + v1ti_result = __builtin_vec_init_v1ti (ti_arg); + if (v1ti_result[0] != v1ti_expected_result[0]) + { +#if DEBUG + printf ("test_vec_init_v1ti: v1ti_result[0] = "); + print_i128 (v1ti_result[0]); + printf( "vf_expected_result[0] = "); + print_i128 (v1ti_expected_result[0]); + printf("\n"); +#else + abort(); +#endif + } +} + +void test_vec_init_v2df (double d_arg1, double d_arg2, + vector double v2df_expected_result) +{ + vector double v2df_result; + int i; + + v2df_result = __builtin_vec_init_v2df (d_arg1, d_arg2); + + for ( i= 0; i < 2; i++) + if (v2df_result[i] != v2df_expected_result[i]) +#if DEBUG + printf ("test_vec_init_v2df: v2df_result[%d] = %f, v2df_expected_result[%d] = %f\n", + i, v2df_result[i], i, v2df_expected_result[i]); +#else + abort(); +#endif +} + +void test_vec_init_v2di (signed long long sl_arg1, signed long long sl_arg2, + vector signed long long v2di_expected_result) +{ + vector signed long long v2di_result; + int i; + + v2di_result = __builtin_vec_init_v2di (sl_arg1, sl_arg2); + + for ( i= 0; i < 2; i++) + if (v2di_result[i] != v2di_expected_result[i]) +#if DEBUG + printf ("test_vec_init_v2di: v2di_result[%d] = %lld, v2df_expected_result[%d] = %lld\n", + i, v2di_result[i], i, v2di_expected_result[i]); +#else + abort(); +#endif +} + +void test_vec_set_v1ti (vector __int128_t v1ti_arg, __int128_t ti_arg, + vector __int128_t v1ti_expected_result) +{ + vector __int128_t v1ti_result; + + v1ti_result = __builtin_vec_set_v1ti (v1ti_arg, ti_arg, 0); + if (v1ti_result[0] != v1ti_expected_result[0]) + { +#if DEBUG + printf ("test_vec_set_v1ti: v1ti_result[0] = "); + print_i128 (v1ti_result[0]); + printf( "vf_expected_result[0] = "); + print_i128 (v1ti_expected_result[0]); + printf("\n"); +#else + abort(); +#endif + } +} + +void test_vec_set_v2df (vector double v2df_arg, double d_arg, + vector double v2df_expected_result) +{ + vector double v2df_result; + int i; + + v2df_result = __builtin_vec_set_v2df (v2df_arg, d_arg, 0); + + for ( i= 0; i < 2; i++) + if (v2df_result[i] != v2df_expected_result[i]) +#if DEBUG + printf ("test_vec_set_v2df: v2df_result[%d] = %f, v2df_expected_result[%d] = %f\n", + i, v2df_result[i], i, v2df_expected_result[i]); +#else + abort(); +#endif +} + +void test_vec_set_v2di (vector signed long long v2di_arg, signed long long sl_arg, + vector signed long long v2di_expected_result) +{ + vector signed long long v2di_result; + int i; + + v2di_result = __builtin_vec_set_v2di (v2di_arg, sl_arg, 1); + + for ( i= 0; i < 2; i++) + if (v2di_result[i] != v2di_expected_result[i]) +#if DEBUG + printf ("test_vec_set_v2di: v2di_result[%d] = %lld, v2df_expected_result[%d] = %lld\n", + i, v2di_result[i], i, v2di_expected_result[i]); +#else + abort(); +#endif +} + +int main () +{ + __int128_t ti_arg1; + vector __int128_t v1ti_arg1, v1ti_expected_result; + double d_arg1, d_arg2; + vector double v2df_arg1, v2df_expected_result; + signed long long sl_arg1, sl_arg2; + vector signed long long v2di_arg1, v2di_expected_result; + + ti_arg1 = 123456789123456789; + ti_arg1 = (ti_arg1 << 64) | 123456789123456789; + v1ti_expected_result = (vector __int128_t) ti_arg1; + test_vec_init_v1ti (ti_arg1, v1ti_expected_result); + + d_arg1 = 123456.2; + d_arg2 = 987654.4; + v2df_expected_result = (vector double) {123456.2, 987654.4}; + test_vec_init_v2df (d_arg1, d_arg2, v2df_expected_result); + + sl_arg1 = 1234560; + sl_arg2 = 9876540; + v2di_expected_result = (vector signed long long) {1234560, 9876540}; + test_vec_init_v2di (sl_arg1, sl_arg2, v2di_expected_result); + + v1ti_arg1 = (vector __int128_t) {987654321987654321}; + ti_arg1 = 12345678; + v1ti_expected_result = (vector __int128_t) {12345678}; + test_vec_set_v1ti (v1ti_arg1, ti_arg1, v1ti_expected_result); + + d_arg1 = 123.123; + v2df_arg1 = (vector double) {12345678.2, 987654.4}; + v2df_expected_result = (vector double) {123.123, 987654.4}; + test_vec_set_v2df (v2df_arg1, d_arg1, v2df_expected_result); + + sl_arg1 = 1234560; + v2di_arg1 = (vector signed long long) {123, 456}; + v2di_expected_result = (vector signed long long) {123, 1234560}; + test_vec_set_v2di (v2di_arg1, sl_arg1, v2di_expected_result); + + return 0; +} -- 2.43.0