From 5d30228e2b9837e66827acfe95c9a74c90c1d42b Mon Sep 17 00:00:00 2001 From: Kelvin Nilsen Date: Tue, 7 May 2019 21:40:46 +0000 Subject: [PATCH] re PR middle-end/89765 (Multiple problems with vec-insert implementation on PowerPC) gcc/ChangeLog: 2019-05-07 Kelvin Nilsen PR target/89765 * config/rs6000/rs6000-c.c (altivec_resolve_overloaded_builtin): In handling of ALTIVEC_BUILTIN_VEC_INSERT, use modular arithmetic to compute vector element selector for both constant and variable operands. gcc/testsuite/ChangeLog: 2019-05-07 Kelvin Nilsen PR target/89765 * gcc.target/powerpc/pr89765-mc.c: New test. * gcc.target/powerpc/vsx-builtin-10c.c: New test. * gcc.target/powerpc/vsx-builtin-10d.c: New test. * gcc.target/powerpc/vsx-builtin-11c.c: New test. * gcc.target/powerpc/vsx-builtin-11d.c: New test. * gcc.target/powerpc/vsx-builtin-12c.c: New test. * gcc.target/powerpc/vsx-builtin-12d.c: New test. * gcc.target/powerpc/vsx-builtin-13c.c: New test. * gcc.target/powerpc/vsx-builtin-13d.c: New test. * gcc.target/powerpc/vsx-builtin-14c.c: New test. * gcc.target/powerpc/vsx-builtin-14d.c: New test. * gcc.target/powerpc/vsx-builtin-15c.c: New test. * gcc.target/powerpc/vsx-builtin-15d.c: New test. * gcc.target/powerpc/vsx-builtin-16c.c: New test. * gcc.target/powerpc/vsx-builtin-16d.c: New test. * gcc.target/powerpc/vsx-builtin-17c.c: New test. * gcc.target/powerpc/vsx-builtin-17d.c: New test. * gcc.target/powerpc/vsx-builtin-18c.c: New test. * gcc.target/powerpc/vsx-builtin-18d.c: New test. * gcc.target/powerpc/vsx-builtin-19c.c: New test. * gcc.target/powerpc/vsx-builtin-19d.c: New test. * gcc.target/powerpc/vsx-builtin-20c.c: New test. * gcc.target/powerpc/vsx-builtin-20d.c: New test. * gcc.target/powerpc/vsx-builtin-9c.c: New test. * gcc.target/powerpc/vsx-builtin-9d.c: New test. From-SVN: r270982 --- gcc/ChangeLog | 8 + gcc/config/rs6000/rs6000-c.c | 22 +- gcc/testsuite/ChangeLog | 29 ++ gcc/testsuite/gcc.target/powerpc/pr89765-mc.c | 400 ++++++++++++++++++ .../gcc.target/powerpc/vsx-builtin-10c.c | 155 +++++++ .../gcc.target/powerpc/vsx-builtin-10d.c | 155 +++++++ .../gcc.target/powerpc/vsx-builtin-11c.c | 149 +++++++ .../gcc.target/powerpc/vsx-builtin-11d.c | 149 +++++++ .../gcc.target/powerpc/vsx-builtin-12c.c | 112 +++++ .../gcc.target/powerpc/vsx-builtin-12d.c | 112 +++++ .../gcc.target/powerpc/vsx-builtin-13c.c | 115 +++++ .../gcc.target/powerpc/vsx-builtin-13d.c | 115 +++++ .../gcc.target/powerpc/vsx-builtin-14c.c | 149 +++++++ .../gcc.target/powerpc/vsx-builtin-14d.c | 149 +++++++ .../gcc.target/powerpc/vsx-builtin-15c.c | 151 +++++++ .../gcc.target/powerpc/vsx-builtin-15d.c | 151 +++++++ .../gcc.target/powerpc/vsx-builtin-16c.c | 180 ++++++++ .../gcc.target/powerpc/vsx-builtin-16d.c | 163 +++++++ .../gcc.target/powerpc/vsx-builtin-17c.c | 154 +++++++ .../gcc.target/powerpc/vsx-builtin-17d.c | 154 +++++++ .../gcc.target/powerpc/vsx-builtin-18c.c | 148 +++++++ .../gcc.target/powerpc/vsx-builtin-18d.c | 148 +++++++ .../gcc.target/powerpc/vsx-builtin-19c.c | 122 ++++++ .../gcc.target/powerpc/vsx-builtin-19d.c | 122 ++++++ .../gcc.target/powerpc/vsx-builtin-20c.c | 115 +++++ .../gcc.target/powerpc/vsx-builtin-20d.c | 115 +++++ .../gcc.target/powerpc/vsx-builtin-9c.c | 164 +++++++ .../gcc.target/powerpc/vsx-builtin-9d.c | 164 +++++++ 28 files changed, 3862 insertions(+), 8 deletions(-) create mode 100644 gcc/testsuite/gcc.target/powerpc/pr89765-mc.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-10c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-10d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-11c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-11d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-12c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-12d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-13c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-13d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-14c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-14d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-15c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-15d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-16c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-16d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-17c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-17d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-18c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-18d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-19c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-19d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-20c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-20d.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-9c.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-builtin-9d.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 2ebed19240e..9571c3b62b6 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2019-05-07 Kelvin Nilsen + + PR target/89765 + * config/rs6000/rs6000-c.c (altivec_resolve_overloaded_builtin): + In handling of ALTIVEC_BUILTIN_VEC_INSERT, use modular arithmetic + to compute vector element selector for both constant and variable + operands. + 2019-05-07 Uroš Bizjak * config/i386/i386.md (cvt_mnemonic): New mode attribute. diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c index 063d4acfafb..7c28d4d8176 100644 --- a/gcc/config/rs6000/rs6000-c.c +++ b/gcc/config/rs6000/rs6000-c.c @@ -6736,11 +6736,13 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, /* If we can use the VSX xxpermdi instruction, use that for insert. */ mode = TYPE_MODE (arg1_type); if ((mode == V2DFmode || mode == V2DImode) && VECTOR_UNIT_VSX_P (mode) - && TREE_CODE (arg2) == INTEGER_CST - && wi::ltu_p (wi::to_wide (arg2), 2)) + && TREE_CODE (arg2) == INTEGER_CST) { + wide_int selector = wi::to_wide (arg2); + selector = wi::umod_trunc (selector, 2); tree call = NULL_TREE; + arg2 = wide_int_to_tree (TREE_TYPE (arg2), selector); if (mode == V2DFmode) call = rs6000_builtin_decls[VSX_BUILTIN_VEC_SET_V2DF]; else if (mode == V2DImode) @@ -6752,11 +6754,12 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, return build_call_expr (call, 3, arg1, arg0, arg2); } else if (mode == V1TImode && VECTOR_UNIT_VSX_P (mode) - && TREE_CODE (arg2) == INTEGER_CST - && wi::eq_p (wi::to_wide (arg2), 0)) + && TREE_CODE (arg2) == INTEGER_CST) { tree call = rs6000_builtin_decls[VSX_BUILTIN_VEC_SET_V1TI]; + wide_int selector = wi::zero(32); + arg2 = wide_int_to_tree (TREE_TYPE (arg2), selector); /* Note, __builtin_vec_insert_ has vector and scalar types reversed. */ return build_call_expr (call, 3, arg1, arg0, arg2); @@ -6764,10 +6767,13 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, /* Build *(((arg1_inner_type*)&(vector type){arg1})+arg2) = arg0. */ arg1_inner_type = TREE_TYPE (arg1_type); - arg2 = build_binary_op (loc, BIT_AND_EXPR, arg2, - build_int_cst (TREE_TYPE (arg2), - TYPE_VECTOR_SUBPARTS (arg1_type) - - 1), 0); + if (TYPE_VECTOR_SUBPARTS (arg1_type) == 1) + arg2 = build_int_cst (TREE_TYPE (arg2), 0); + else + arg2 = build_binary_op (loc, BIT_AND_EXPR, arg2, + build_int_cst (TREE_TYPE (arg2), + TYPE_VECTOR_SUBPARTS (arg1_type) + - 1), 0); decl = build_decl (loc, VAR_DECL, NULL_TREE, arg1_type); DECL_EXTERNAL (decl) = 0; TREE_PUBLIC (decl) = 0; diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index ae3e09aae46..a7b40dfc64e 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,32 @@ +2019-05-07 Kelvin Nilsen + + PR target/89765 + * gcc.target/powerpc/pr89765-mc.c: New test. + * gcc.target/powerpc/vsx-builtin-10c.c: New test. + * gcc.target/powerpc/vsx-builtin-10d.c: New test. + * gcc.target/powerpc/vsx-builtin-11c.c: New test. + * gcc.target/powerpc/vsx-builtin-11d.c: New test. + * gcc.target/powerpc/vsx-builtin-12c.c: New test. + * gcc.target/powerpc/vsx-builtin-12d.c: New test. + * gcc.target/powerpc/vsx-builtin-13c.c: New test. + * gcc.target/powerpc/vsx-builtin-13d.c: New test. + * gcc.target/powerpc/vsx-builtin-14c.c: New test. + * gcc.target/powerpc/vsx-builtin-14d.c: New test. + * gcc.target/powerpc/vsx-builtin-15c.c: New test. + * gcc.target/powerpc/vsx-builtin-15d.c: New test. + * gcc.target/powerpc/vsx-builtin-16c.c: New test. + * gcc.target/powerpc/vsx-builtin-16d.c: New test. + * gcc.target/powerpc/vsx-builtin-17c.c: New test. + * gcc.target/powerpc/vsx-builtin-17d.c: New test. + * gcc.target/powerpc/vsx-builtin-18c.c: New test. + * gcc.target/powerpc/vsx-builtin-18d.c: New test. + * gcc.target/powerpc/vsx-builtin-19c.c: New test. + * gcc.target/powerpc/vsx-builtin-19d.c: New test. + * gcc.target/powerpc/vsx-builtin-20c.c: New test. + * gcc.target/powerpc/vsx-builtin-20d.c: New test. + * gcc.target/powerpc/vsx-builtin-9c.c: New test. + * gcc.target/powerpc/vsx-builtin-9d.c: New test. + 2019-05-07 Alejandro Martinez * gcc.target/aarch64/sve/sad_1.c: New test for sum of absolute diff --git a/gcc/testsuite/gcc.target/powerpc/pr89765-mc.c b/gcc/testsuite/gcc.target/powerpc/pr89765-mc.c new file mode 100644 index 00000000000..8384536058b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr89765-mc.c @@ -0,0 +1,400 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx -O2" } */ + +/* 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. */ + +#include +#include +#include + +#include + +static vector unsigned __int128 +deoptimize_uint128 (vector unsigned __int128 a) +{ + __asm__ (" # %x0" : "+v" (a)); + return a; +} + +static vector unsigned long long int +deoptimize_ulong (vector unsigned long long int a) +{ + __asm__ (" # %x0" : "+v" (a)); + return a; +} + +static vector unsigned int +deoptimize_uint (vector unsigned int a) +{ + __asm__ (" # %x0" : "+v" (a)); + return a; +} + +static vector unsigned char +deoptimize_uchar (vector unsigned char a) +{ + __asm__ (" # %x0" : "+v" (a)); + return a; +} + +static vector unsigned short +deoptimize_ushort (vector unsigned short a) +{ + __asm__ (" # %x0" : "+v" (a)); + return a; +} + +__attribute ((noinline)) +vector unsigned __int128 +set_auto_n_uint128 (vector unsigned __int128 a, int n, unsigned __int128 x) +{ + return vec_insert (x, a, n); +} + +__attribute ((noinline)) +vector unsigned long long int +set_auto_n_ulong (vector unsigned long long int a, int n, + unsigned long long int x) +{ + return vec_insert (x, a, n); +} + +__attribute ((noinline)) +vector unsigned int +set_auto_n_uint (vector unsigned int a, int n, unsigned int x) +{ + return vec_insert (x, a, n); +} + +__attribute ((noinline)) +vector unsigned char +set_auto_n_uchar (vector unsigned char a, int n, unsigned char x) +{ + return vec_insert (x, a, n); +} + +__attribute ((noinline)) +vector unsigned short +set_auto_n_ushort (vector unsigned short a, int n, unsigned short x) +{ + return vec_insert (x, a, n); +} + +__attribute ((noinline)) +unsigned __int128 +get_auto_n_uint128 (vector unsigned __int128 a, int n) +{ + return vec_extract (a, n); +} + +__attribute ((noinline)) +unsigned long long int +get_auto_n_ulong (vector unsigned long long int a, int n) +{ + return vec_extract (a, n); +} + +__attribute ((noinline)) +unsigned int +get_auto_n_uint (vector unsigned int a, int n) +{ + return vec_extract (a, n); +} + +__attribute ((noinline)) +unsigned char +get_auto_n_uchar (vector unsigned char a, int n) +{ + return vec_extract (a, n); +} + +__attribute ((noinline)) +unsigned short +get_auto_n_ushort (vector unsigned short a, int n) +{ + return vec_extract (a, n); +} + +int check_uint128_element (int i, unsigned __int128 entry) +{ + printf ("checking uint128 entry at index %d\n", i); + + return (entry == ((((unsigned __int128) 0xffeeddccbbaa9988ULL) << 64) + | 0x0706050403020100ULL)); +} + +unsigned __int128 get_uint128_element (int i) +{ + return ((((unsigned __int128) 0xffeeddccbbaa9988ULL) << 64) + | 0x0706050403020100ULL); +} + +int check_ulong_element (int i, unsigned long long int entry) +{ + printf ("checking ulong entry 0x%llx at index %d\n", entry, i); + + switch (i % 2) + { + case 0: return (entry == 0x9999901010ULL); + case 1: return (entry == 0x7777733333ULL); + default: + return 0; + } +} + +unsigned long long int get_ulong_element (int i) +{ + switch (i % 2) + { + case 0: return 0x9999901010ULL; + case 1: return 0x7777733333ULL; + } +} + +int check_uint_element (int i, unsigned int entry) +{ + printf ("checking uint entry 0x%x at index %d\n", entry, i); + + switch (i % 4) + { + case 0: return (entry == 0x99999); + case 1: return (entry == 0x01010); + case 2: return (entry == 0x77777); + case 3: return (entry == 0x33333); + default: + return 0; + } +} + +unsigned int get_uint_element (int i) +{ + switch (i % 4) + { + case 0: return 0x99999; + case 1: return 0x01010; + case 2: return 0x77777; + case 3: return 0x33333; + } +} + +int check_uchar_element (int i, unsigned char entry) +{ + printf ("checking uchar entry 0x%x at index %d\n", entry, i); + switch (i % 16) + { + case 0: return (entry == 0x90); + case 1: return (entry == 0x80); + case 2: return (entry == 0x70); + case 3: return (entry == 0x60); + case 4: return (entry == 0x50); + case 5: return (entry == 0x40); + case 6: return (entry == 0x30); + case 7: return (entry == 0x20); + case 8: return (entry == 0x10); + case 9: return (entry == 0xf0); + case 10: return (entry == 0xe0); + case 11: return (entry == 0xd0); + case 12: return (entry == 0xc0); + case 13: return (entry == 0xb0); + case 14: return (entry == 0xa0); + case 15: return (entry == 0xff); + default: + return 0; + } +} + +unsigned char get_uchar_element (int i) +{ + switch (i % 16) + { + case 0: return 0x90; + case 1: return 0x80; + case 2: return 0x70; + case 3: return 0x60; + case 4: return 0x50; + case 5: return 0x40; + case 6: return 0x30; + case 7: return 0x20; + case 8: return 0x10; + case 9: return 0xf0; + case 10: return 0xe0; + case 11: return 0xd0; + case 12: return 0xc0; + case 13: return 0xb0; + case 14: return 0xa0; + case 15: return 0xff; + } +} + +int check_ushort_element (int i, unsigned short entry) +{ + printf ("checking ushort entry 0x%x at index %d\n", entry, i); + switch (i % 8) + { + case 0: return (entry == 0x9988); + case 1: return (entry == 0x8877); + case 2: return (entry == 0x7766); + case 3: return (entry == 0x6655); + case 4: return (entry == 0x5544); + case 5: return (entry == 0x4433); + case 6: return (entry == 0x3322); + case 7: return (entry == 0x2211); + default: + return 0; + } +} + +unsigned short get_ushort_element (int i) +{ + switch (i % 8) + { + case 0: return 0x9988; + case 1: return 0x8877; + case 2: return 0x7766; + case 3: return 0x6655; + case 4: return 0x5544; + case 5: return 0x4433; + case 6: return 0x3322; + case 7: return 0x2211; + } +} + +vector unsigned __int128 +init_auto_uint128 (vector unsigned __int128 a) +{ + int i; + for (i = 0; i < 32; i += 3) + a = set_auto_n_uint128 (a, i, get_uint128_element (i)); + return a; +} + +void do_auto_uint128 (vector unsigned __int128 a) +{ + int i; + unsigned __int128 c; + for (i = 0; i < 32; i += 3) + { + c = get_auto_n_uint128 (a, i); + if (!check_uint128_element (i, c)) abort (); + } +} + +vector unsigned long long int +init_auto_ulong (vector unsigned long long int a) +{ + int i; + for (i = 0; i < 32; i += 3) + a = set_auto_n_ulong (a, i, get_ulong_element (i)); + return a; +} + +void do_auto_ulong (vector unsigned long long int a) +{ + int i; + unsigned long long int c; + for (i = 0; i < 32; i += 3) + { + c = get_auto_n_ulong (a, i); + if (!check_ulong_element (i, c)) abort (); + } + } + +vector unsigned int init_auto_uint (vector unsigned int a) +{ + int i; + for (i = 0; i < 32; i += 3) + a = set_auto_n_uint (a, i, get_uint_element (i)); + return a; +} + +void do_auto_uint (vector unsigned int a) +{ + int i; + unsigned int c; + for (i = 0; i < 32; i += 3) + { + c = get_auto_n_uint (a, i); + if (!check_uint_element (i, c)) abort (); + } + } + +vector unsigned short init_auto_ushort ( vector unsigned short a ) +{ + int i; + for (i = 0; i < 32; i += 3) + a = set_auto_n_ushort (a, i, get_ushort_element (i)); + return a; +} + +void do_auto_ushort (vector unsigned short a) +{ + int i; + unsigned short c; + for (i = 0; i < 32; i += 3) + { + c = get_auto_n_ushort (a, i); + if (!check_ushort_element (i, c)) abort (); + } +} + +vector unsigned char init_auto_uchar (vector unsigned char a) +{ + int i; + for (i = 0; i < 32; i += 3) + a = set_auto_n_uchar (a, i, get_uchar_element (i)); + return a; +} + +void do_auto_uchar (vector unsigned char a) +{ + int i; + unsigned char c; + for (i = 0; i < 32; i += 3) + { + c = get_auto_n_uchar (a, i); + if (!check_uchar_element (i, c)) abort (); + } +} + +int +main (void) +{ + size_t i; + + vector unsigned __int128 u = { 0 }; + vector unsigned __int128 du; + + vector unsigned long long int v = { 0, 0 }; + vector unsigned long long int dv; + + vector unsigned int x = { 0, 0, 0, 0 }; + vector unsigned int dx; + + vector unsigned char y = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + vector unsigned char dy; + + vector unsigned short z = { 0, 0, 0, 0, 0, 0, 0, 0 }; + vector unsigned short dz; + + du = init_auto_uint128 (u); + dv = init_auto_ulong (v); + dx = init_auto_uint (x); + dy = init_auto_uchar (y); + dz = init_auto_ushort (z); + + du = deoptimize_uint128 (du); + dv = deoptimize_ulong (dv); + dx = deoptimize_uint (dx); + dy = deoptimize_uchar (dy); + dz = deoptimize_ushort (dz); + + do_auto_uint128 (du); + do_auto_ulong (dv); + do_auto_uint (dx); + do_auto_uchar (dy); + do_auto_ushort (dz); + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-10c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-10c.c new file mode 100644 index 00000000000..5ed6424d64f --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-10c.c @@ -0,0 +1,155 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector short s3 (vector short v, short x) +{ + return vec_insert (x, v, 3); +} + +vector short s7 (vector short v, short x) +{ + return vec_insert (x, v, 7); +} + +vector short s21 (vector short v, short x) +{ + return vec_insert (x, v, 21); +} + +vector short s30 (vector short v, short x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector short ms3 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 3); +} + +vector short ms7 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 7); +} + +vector short ms21 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 21); +} + +vector short ms30 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector short ci (vector short v, int i, short x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector short mci (vector short *vp, int i, short x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, short *argv[]) { + vector short sv = { + CONST0, CONST1, CONST2, CONST3, CONST4, CONST5, CONST6, CONST7 }; + short s; + + sv = s3 (sv, CONST6); + if (sv [3] != CONST6) + abort (); + + sv = s7 (sv, CONST4); + if (sv [7] != CONST4) + abort (); + + sv = s21 (sv, CONST3); + if (sv [5] != CONST3) + abort (); + + sv = s30 (sv, CONST2); + if (sv [6] != CONST2) + abort (); + + sv = ms3 (&sv, CONST5); + if (sv [3] != CONST5) + abort (); + + sv = ms7 (&sv, CONST1); + if (sv [7] != CONST1) + abort (); + + sv = ms21 (&sv, CONST2); + if (sv [5] != CONST2) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [6] != CONST0) + abort (); + + sv = ci (sv, 5, CONST6); + if (sv [5] != CONST6) + abort (); + + sv = ci (sv, 2, CONST4); + if (sv [2] != CONST4) + abort (); + + sv = ci (sv, 15, CONST3); + if (sv [7] != CONST3) + abort (); + + sv = ci (sv, 28, CONST3); + if (sv [4] != CONST3) + abort (); + + sv = mci (&sv, 5, CONST3); + if (sv [5] != CONST3) + abort (); + + sv = mci (&sv, 12, CONST7); + if (sv [4] != CONST7) + abort (); + + sv = mci (&sv, 25, CONST6); + if (sv [1] != CONST6) + abort (); + + sv = mci (&sv, 16, CONST5); + if (sv [0] != CONST5) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-10d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-10d.c new file mode 100644 index 00000000000..c9aaecad920 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-10d.c @@ -0,0 +1,155 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec -O3" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector short s3 (vector short v, short x) +{ + return vec_insert (x, v, 3); +} + +vector short s7 (vector short v, short x) +{ + return vec_insert (x, v, 7); +} + +vector short s21 (vector short v, short x) +{ + return vec_insert (x, v, 21); +} + +vector short s30 (vector short v, short x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector short ms3 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 3); +} + +vector short ms7 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 7); +} + +vector short ms21 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 21); +} + +vector short ms30 (vector short *vp, short x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector short ci (vector short v, int i, short x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector short mci (vector short *vp, int i, short x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, short *argv[]) { + vector short sv = { + CONST0, CONST1, CONST2, CONST3, CONST4, CONST5, CONST6, CONST7 }; + short s; + + sv = s3 (sv, CONST6); + if (sv [3] != CONST6) + abort (); + + sv = s7 (sv, CONST4); + if (sv [7] != CONST4) + abort (); + + sv = s21 (sv, CONST3); + if (sv [5] != CONST3) + abort (); + + sv = s30 (sv, CONST2); + if (sv [6] != CONST2) + abort (); + + sv = ms3 (&sv, CONST5); + if (sv [3] != CONST5) + abort (); + + sv = ms7 (&sv, CONST1); + if (sv [7] != CONST1) + abort (); + + sv = ms21 (&sv, CONST2); + if (sv [5] != CONST2) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [6] != CONST0) + abort (); + + sv = ci (sv, 5, CONST6); + if (sv [5] != CONST6) + abort (); + + sv = ci (sv, 2, CONST4); + if (sv [2] != CONST4) + abort (); + + sv = ci (sv, 15, CONST3); + if (sv [7] != CONST3) + abort (); + + sv = ci (sv, 28, CONST3); + if (sv [4] != CONST3) + abort (); + + sv = mci (&sv, 5, CONST3); + if (sv [5] != CONST3) + abort (); + + sv = mci (&sv, 12, CONST7); + if (sv [4] != CONST7) + abort (); + + sv = mci (&sv, 25, CONST6); + if (sv [1] != CONST6) + abort (); + + sv = mci (&sv, 16, CONST5); + if (sv [0] != CONST5) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-11c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-11c.c new file mode 100644 index 00000000000..8e514aa2b1f --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-11c.c @@ -0,0 +1,149 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector int s3 (vector int v, int x) +{ + return vec_insert (x, v, 3); +} + +vector int s1 (vector int v, int x) +{ + return vec_insert (x, v, 1); +} + +vector int s21 (vector int v, int x) +{ + return vec_insert (x, v, 21); +} + +vector int s30 (vector int v, int x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector int ms3 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 3); +} + +vector int ms1 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 1); +} + +vector int ms21 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 21); +} + +vector int ms30 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector int ci (vector int v, int i, int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector int mci(vector int *vp, int i, int x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, int *argv[]) { + vector int sv = { CONST0, CONST1, CONST2, CONST3 }; + int s; + + sv = s3 (sv, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = s1 (sv, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = s21 (sv, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = s30 (sv, CONST1); + if (sv [2] != CONST1) + abort (); + + sv = ms3 (&sv, CONST2); + if (sv [3] != CONST2) + abort (); + + sv = ms1 (&sv, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = ms21 (&sv, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [2] != CONST0) + abort (); + + sv = ci (sv, 5, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = ci (sv, 2, CONST3); + if (sv [2] != CONST3) + abort (); + + sv = ci (sv, 15, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = ci (sv, 28, CONST3); + if (sv [0] != CONST3) + abort (); + + sv = mci (&sv, 5, CONST2); + if (sv [1] != CONST2) + abort (); + + sv = mci (&sv, 12, CONST1); + if (sv [0] != CONST1) + abort (); + + sv = mci (&sv, 25, CONST2); + if (sv [1] != CONST2) + abort (); + + sv = mci (&sv, 16, CONST3); + if (sv [0] != CONST3) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-11d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-11d.c new file mode 100644 index 00000000000..116802aeece --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-11d.c @@ -0,0 +1,149 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec -O3" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector int s3 (vector int v, int x) +{ + return vec_insert (x, v, 3); +} + +vector int s1 (vector int v, int x) +{ + return vec_insert (x, v, 1); +} + +vector int s21 (vector int v, int x) +{ + return vec_insert (x, v, 21); +} + +vector int s30 (vector int v, int x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector int ms3 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 3); +} + +vector int ms1 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 1); +} + +vector int ms21 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 21); +} + +vector int ms30 (vector int *vp, int x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector int ci (vector int v, int i, int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector int mci(vector int *vp, int i, int x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, int *argv[]) { + vector int sv = { CONST0, CONST1, CONST2, CONST3 }; + int s; + + sv = s3 (sv, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = s1 (sv, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = s21 (sv, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = s30 (sv, CONST1); + if (sv [2] != CONST1) + abort (); + + sv = ms3 (&sv, CONST2); + if (sv [3] != CONST2) + abort (); + + sv = ms1 (&sv, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = ms21 (&sv, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [2] != CONST0) + abort (); + + sv = ci (sv, 5, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = ci (sv, 2, CONST3); + if (sv [2] != CONST3) + abort (); + + sv = ci (sv, 15, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = ci (sv, 28, CONST3); + if (sv [0] != CONST3) + abort (); + + sv = mci (&sv, 5, CONST2); + if (sv [1] != CONST2) + abort (); + + sv = mci (&sv, 12, CONST1); + if (sv [0] != CONST1) + abort (); + + sv = mci (&sv, 25, CONST2); + if (sv [1] != CONST2) + abort (); + + sv = mci (&sv, 16, CONST3); + if (sv [0] != CONST3) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-12c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-12c.c new file mode 100644 index 00000000000..1e57bc46cdd --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-12c.c @@ -0,0 +1,112 @@ +/* { 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. */ + +#include + +extern void abort (void); + +#define CONST0 (31415926539LL) +#define CONST1 (2 * 31415926539LL) +#define CONST2 (3 * 31415926539LL) +#define CONST3 (4 * 31415926539LL) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector long long int e0 (vector long long int v, long long int x) +{ + return vec_insert (x, v, 0); +} + +vector long long int e3 (vector long long int v, long long int x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector long long int me0 (vector long long int *vp, long long int x) +{ + return vec_insert (x, *vp, 0); +} + +vector long long int me3 (vector long long int *vp, long long int x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector long long int ei (vector long long int v, int i, long long int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector long long int mei (vector long long int *vp, int i, long long int x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector long long int dv = { CONST0, CONST1 }; + long long int d; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e3 (dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = me0 (&dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me3 (&dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = ei (dv, 0, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 1, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = ei (dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 3, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = mei (&dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 3, CONST2); + if (dv [1] != CONST2) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-12d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-12d.c new file mode 100644 index 00000000000..3bf06085fb5 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-12d.c @@ -0,0 +1,112 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx -O3" } */ + +/* 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. */ + +#include + +extern void abort (void); + +#define CONST0 (31415926539LL) +#define CONST1 (2 * 31415926539LL) +#define CONST2 (3 * 31415926539LL) +#define CONST3 (4 * 31415926539LL) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector long long int e0 (vector long long int v, long long int x) +{ + return vec_insert (x, v, 0); +} + +vector long long int e3 (vector long long int v, long long int x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector long long int me0 (vector long long int *vp, long long int x) +{ + return vec_insert (x, *vp, 0); +} + +vector long long int me3 (vector long long int *vp, long long int x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector long long int ei (vector long long int v, int i, long long int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector long long int mei (vector long long int *vp, int i, long long int x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector long long int dv = { CONST0, CONST1 }; + long long int d; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e3 (dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = me0 (&dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me3 (&dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = ei (dv, 0, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 1, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = ei (dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 3, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = mei (&dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 3, CONST2); + if (dv [1] != CONST2) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-13c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-13c.c new file mode 100644 index 00000000000..43c6bed7695 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-13c.c @@ -0,0 +1,115 @@ +/* { 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. */ + +#include + +#define SIGNED signed + +extern void abort (void); + +#define CONST0 (((SIGNED __int128) 31415926539) << 60) +#define CONST1 (((SIGNED __int128) 31415926539) << 55) +#define CONST2 (((SIGNED __int128) 31415926539) << 50) +#define CONST3 (((SIGNED __int128) 31415926539) << 45) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector SIGNED __int128 e0 (vector SIGNED __int128 v, SIGNED __int128 x) +{ + return vec_insert (x, v, 0); +} + +vector SIGNED __int128 e3 (vector SIGNED __int128 v, SIGNED __int128 x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector SIGNED __int128 me0 (vector SIGNED __int128 *vp, SIGNED __int128 x) +{ + return vec_insert (x, *vp, 0); +} + +vector SIGNED __int128 me3 (vector SIGNED __int128 *vp, SIGNED __int128 x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector SIGNED __int128 +ei (vector SIGNED __int128 v, int i, SIGNED __int128 x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector SIGNED __int128 +mei (vector SIGNED __int128 *vp, int i, SIGNED __int128 x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector SIGNED __int128 dv = { CONST0 }; + SIGNED __int128 d; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e3 (dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me0 (&dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me3 (&dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 1, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = ei (dv, 2, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 3, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 0, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = mei (&dv, 1, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = mei (&dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 3, CONST2); + if (dv [0] != CONST2) + abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-13d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-13d.c new file mode 100644 index 00000000000..257de552e64 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-13d.c @@ -0,0 +1,115 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx -O3" } */ + +/* 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. */ + +#include + +#define SIGNED signed + +extern void abort (void); + +#define CONST0 (((SIGNED __int128) 31415926539) << 60) +#define CONST1 (((SIGNED __int128) 31415926539) << 55) +#define CONST2 (((SIGNED __int128) 31415926539) << 50) +#define CONST3 (((SIGNED __int128) 31415926539) << 45) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector SIGNED __int128 e0 (vector SIGNED __int128 v, SIGNED __int128 x) +{ + return vec_insert (x, v, 0); +} + +vector SIGNED __int128 e3 (vector SIGNED __int128 v, SIGNED __int128 x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector SIGNED __int128 me0 (vector SIGNED __int128 *vp, SIGNED __int128 x) +{ + return vec_insert (x, *vp, 0); +} + +vector SIGNED __int128 me3 (vector SIGNED __int128 *vp, SIGNED __int128 x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector SIGNED __int128 +ei (vector SIGNED __int128 v, int i, SIGNED __int128 x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector SIGNED __int128 +mei (vector SIGNED __int128 *vp, int i, SIGNED __int128 x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector SIGNED __int128 dv = { CONST0 }; + SIGNED __int128 d; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e3 (dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me0 (&dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me3 (&dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 1, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = ei (dv, 2, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 3, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 0, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = mei (&dv, 1, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = mei (&dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 3, CONST2); + if (dv [0] != CONST2) + abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-14c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-14c.c new file mode 100644 index 00000000000..5ba4bd59eb3 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-14c.c @@ -0,0 +1,149 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 ((float) (3.1415926539)) +#define CONST1 ((float) (3.1415926539 * 2)) +#define CONST2 ((float) (3.1415926539 * 3)) +#define CONST3 ((float) (3.1415926539 * 4)) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector float e0(vector float v, float x) +{ + return vec_insert (x, v, 0); +} + +vector float e1(vector float v, float x) +{ + return vec_insert (x, v, 1); +} + +vector float e7(vector float v, float x) +{ + return vec_insert (x, v, 7); +} + +vector float e8(vector float v, float x) +{ + return vec_insert (x, v, 8); +} + +/* Test for vector residing in memory. */ +vector float me0(vector float *vp, float x) +{ + return vec_insert (x, *vp, 0); +} + +vector float me1(vector float *vp, float x) +{ + return vec_insert (x, *vp, 1); +} + +vector float me13(vector float *vp, float x) +{ + return vec_insert (x, *vp, 13); +} + +vector float me15(vector float *vp, float x) +{ + return vec_insert (x, *vp, 15); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector float ei(vector float v, int i, float x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector float mei(vector float *vp, int i, float x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, char *argv[]) { + vector float dv = { CONST0, CONST1, CONST2, CONST3 }; + float d; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e1 (dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = e7 (dv, CONST2); + if (dv [3] != CONST2) + abort (); + + dv = e8 (dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me0 (&dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me1 (&dv, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = me13 (&dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = me15 (&dv, CONST1); + if (dv [3] != CONST1) + abort (); + + dv = ei (dv, 0, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 2, CONST1); + if (dv [2] != CONST1) + abort (); + + dv = ei (dv, 11, CONST0); + if (dv [3] != CONST0) + abort (); + + dv = ei (dv, 17, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = mei (&dv, 15, CONST1); + if (dv [3] != CONST1) + abort (); + + dv = mei (&dv, 6, CONST0); + if (dv [2] != CONST0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-14d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-14d.c new file mode 100644 index 00000000000..63784a2e220 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-14d.c @@ -0,0 +1,149 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec -O3" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 ((float) (3.1415926539)) +#define CONST1 ((float) (3.1415926539 * 2)) +#define CONST2 ((float) (3.1415926539 * 3)) +#define CONST3 ((float) (3.1415926539 * 4)) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector float e0(vector float v, float x) +{ + return vec_insert (x, v, 0); +} + +vector float e1(vector float v, float x) +{ + return vec_insert (x, v, 1); +} + +vector float e7(vector float v, float x) +{ + return vec_insert (x, v, 7); +} + +vector float e8(vector float v, float x) +{ + return vec_insert (x, v, 8); +} + +/* Test for vector residing in memory. */ +vector float me0(vector float *vp, float x) +{ + return vec_insert (x, *vp, 0); +} + +vector float me1(vector float *vp, float x) +{ + return vec_insert (x, *vp, 1); +} + +vector float me13(vector float *vp, float x) +{ + return vec_insert (x, *vp, 13); +} + +vector float me15(vector float *vp, float x) +{ + return vec_insert (x, *vp, 15); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector float ei(vector float v, int i, float x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector float mei(vector float *vp, int i, float x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, char *argv[]) { + vector float dv = { CONST0, CONST1, CONST2, CONST3 }; + float d; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e1 (dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = e7 (dv, CONST2); + if (dv [3] != CONST2) + abort (); + + dv = e8 (dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me0 (&dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me1 (&dv, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = me13 (&dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = me15 (&dv, CONST1); + if (dv [3] != CONST1) + abort (); + + dv = ei (dv, 0, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 2, CONST1); + if (dv [2] != CONST1) + abort (); + + dv = ei (dv, 11, CONST0); + if (dv [3] != CONST0) + abort (); + + dv = ei (dv, 17, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = mei (&dv, 15, CONST1); + if (dv [3] != CONST1) + abort (); + + dv = mei (&dv, 6, CONST0); + if (dv [2] != CONST0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-15c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-15c.c new file mode 100644 index 00000000000..1a23191e253 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-15c.c @@ -0,0 +1,151 @@ +/* { 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. */ + +#include + +extern void abort (void); + +#define CONST0 (3.1415926539) +#define CONST1 (3.1415926539 * 2) +#define CONST2 (3.1415926539 * 3) +#define CONST3 (3.1415926539 * 4) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector double e0(vector double v, double x) +{ + return vec_insert (x, v, 0); +} + +vector double e1(vector double v, double x) +{ + return vec_insert (x, v, 1); +} + +vector double e2(vector double v, double x) +{ + return vec_insert (x, v, 2); +} + +vector double e3(vector double v, double x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector double me0(vector double *vp, double x) +{ + return vec_insert (x, *vp, 0); +} + +vector double me1(vector double *vp, double x) +{ + return vec_insert (x, *vp, 1); +} + +vector double me2(vector double *vp, double x) +{ + return vec_insert (x, *vp, 2); +} + +vector double me3(vector double *vp, double x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector double ei(vector double v, int i, double x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector double mei(vector double *vp, int i, double x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector double dv; + double d; + dv[0] = CONST0; + dv[1] = CONST1; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e1 (dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = e2 (dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = e3 (dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = me0 (&dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me1 (&dv, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = me2 (&dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me3 (&dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = ei (dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = ei (dv, 2, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 3, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = mei (&dv, 2, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = mei (&dv, 3, CONST3); + if (dv [1] != CONST3) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-15d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-15d.c new file mode 100644 index 00000000000..71f200d831b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-15d.c @@ -0,0 +1,151 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx -O3" } */ + +/* 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. */ + +#include + +extern void abort (void); + +#define CONST0 (3.1415926539) +#define CONST1 (3.1415926539 * 2) +#define CONST2 (3.1415926539 * 3) +#define CONST3 (3.1415926539 * 4) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector double e0(vector double v, double x) +{ + return vec_insert (x, v, 0); +} + +vector double e1(vector double v, double x) +{ + return vec_insert (x, v, 1); +} + +vector double e2(vector double v, double x) +{ + return vec_insert (x, v, 2); +} + +vector double e3(vector double v, double x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector double me0(vector double *vp, double x) +{ + return vec_insert (x, *vp, 0); +} + +vector double me1(vector double *vp, double x) +{ + return vec_insert (x, *vp, 1); +} + +vector double me2(vector double *vp, double x) +{ + return vec_insert (x, *vp, 2); +} + +vector double me3(vector double *vp, double x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector double ei(vector double v, int i, double x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector double mei(vector double *vp, int i, double x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector double dv; + double d; + dv[0] = CONST0; + dv[1] = CONST1; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e1 (dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = e2 (dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = e3 (dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = me0 (&dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me1 (&dv, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = me2 (&dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me3 (&dv, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = ei (dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = ei (dv, 2, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 3, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST0); + if (dv [1] != CONST0) + abort (); + + dv = mei (&dv, 2, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = mei (&dv, 3, CONST3); + if (dv [1] != CONST3) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-16c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-16c.c new file mode 100644 index 00000000000..eea4d406230 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-16c.c @@ -0,0 +1,180 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) +#define CONST8 (8) +#define CONST9 (9) +#define CONSTA (10) +#define CONSTB (11) +#define CONSTC (12) +#define CONSTD (13) +#define CONSTE (14) +#define CONSTF (15) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned char c0 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 0); +} + +vector unsigned char c9 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 9); +} + +vector unsigned char c21 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 21); +} + +vector unsigned char c30 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector unsigned char mc0 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 0); +} + +vector unsigned char mc9 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 9); +} + +vector unsigned char mc21 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 21); +} + +vector unsigned char mc30 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned char ci (vector unsigned char v, int i, unsigned char x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned char mci (vector unsigned char *vp, int i, unsigned char x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, char *argv[]) { + vector unsigned char cv = { CONST0, CONST1, CONST2, CONST3, + CONST4, CONST5, CONST6, CONST7, + CONST8, CONST9, CONSTA, CONSTB, + CONSTC, CONSTD, CONSTE, CONSTF }; + printf ("A\n"); + cv = c0 (cv, CONST3); + if (cv [0] != CONST3) + abort (); + + printf ("B\n"); + cv = c9 (cv, CONST2); + if (cv [9] != CONST2) + abort (); + + printf ("C\n"); + cv = c21 (cv, CONSTF); + if (cv [5] != CONSTF) + abort (); + + printf ("D\n"); + cv = c30 (cv, CONST3); + if (cv [14] != CONST3) + abort (); + + printf ("E\n"); + cv = mc0 (&cv, CONST4); + if (cv [0] != CONST4) + abort (); + + printf ("F\n"); + cv = mc9 (&cv, CONST3); + if (cv [9] != CONST3) + abort (); + + printf ("G\n"); + cv = mc21 (&cv, CONST1); + if (cv [5] != CONST1) + abort (); + + printf ("H\n"); + cv = mc30 (&cv, CONSTC); + if (cv [14] != CONSTC) + abort (); + + printf ("I\n"); + cv = ci (cv, 8, CONSTD); + if (cv [8] != CONSTD) + abort (); + + printf ("J\n"); + cv = ci (cv, 13, CONST5); + if (cv [13] != CONST5) + abort (); + + printf ("K\n"); + cv = ci (cv, 23, CONST6); + if (cv [7] != CONST6) + abort (); + + printf ("L\n"); + cv = ci (cv, 31, CONST7); + if (cv [15] != CONST7) + abort (); + + printf ("M\n"); + cv = mci (&cv, 5, CONST8); + if (cv [5] != CONST8) + abort (); + + printf ("N\n"); + cv = mci (&cv, 12, CONST9); + if (cv [12] != CONST9) + abort (); + + printf ("O\n"); + cv = mci (&cv, 25, CONSTA); + if (cv [9] != CONSTA) + abort (); + + printf ("P\n"); + cv = mci (&cv, 16, CONSTB); + if (cv [0] != CONSTB) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-16d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-16d.c new file mode 100644 index 00000000000..f899e57f2d4 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-16d.c @@ -0,0 +1,163 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec -O3" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) +#define CONST8 (8) +#define CONST9 (9) +#define CONSTA (10) +#define CONSTB (11) +#define CONSTC (12) +#define CONSTD (13) +#define CONSTE (14) +#define CONSTF (15) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned char c0 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 0); +} + +vector unsigned char c9 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 9); +} + +vector unsigned char c21 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 21); +} + +vector unsigned char c30 (vector unsigned char v, unsigned char x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector unsigned char mc0 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 0); +} + +vector unsigned char mc9 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 9); +} + +vector unsigned char mc21 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 21); +} + +vector unsigned char mc30 (vector unsigned char *vp, unsigned char x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned char ci (vector unsigned char v, int i, unsigned char x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned char mci (vector unsigned char *vp, int i, unsigned char x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, char *argv[]) { + vector unsigned char cv = { CONST0, CONST1, CONST2, CONST3, + CONST4, CONST5, CONST6, CONST7, + CONST8, CONST9, CONSTA, CONSTB, + CONSTC, CONSTD, CONSTE, CONSTF }; + cv = c0 (cv, CONST3); + if (cv [0] != CONST3) + abort (); + + cv = c9 (cv, CONST2); + if (cv [9] != CONST2) + abort (); + + cv = c21 (cv, CONSTF); + if (cv [5] != CONSTF) + abort (); + + cv = c30 (cv, CONST3); + if (cv [14] != CONST3) + abort (); + + cv = mc0 (&cv, CONST4); + if (cv [0] != CONST4) + abort (); + + cv = mc9 (&cv, CONST3); + if (cv [9] != CONST3) + abort (); + + cv = mc21 (&cv, CONST1); + if (cv [5] != CONST1) + abort (); + + cv = mc30 (&cv, CONSTC); + if (cv [14] != CONSTC) + abort (); + + cv = ci (cv, 8, CONSTD); + if (cv [8] != CONSTD) + abort (); + + cv = ci (cv, 13, CONST5); + if (cv [13] != CONST5) + abort (); + + cv = ci (cv, 23, CONST6); + if (cv [7] != CONST6) + abort (); + + cv = ci (cv, 31, CONST7); + if (cv [15] != CONST7) + abort (); + + cv = mci (&cv, 5, CONST8); + if (cv [5] != CONST8) + abort (); + + cv = mci (&cv, 12, CONST9); + if (cv [12] != CONST9) + abort (); + + cv = mci (&cv, 25, CONSTA); + if (cv [9] != CONSTA) + abort (); + + cv = mci (&cv, 16, CONSTB); + if (cv [0] != CONSTB) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-17c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-17c.c new file mode 100644 index 00000000000..b95dbcdde15 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-17c.c @@ -0,0 +1,154 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned short s3 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 3); +} + +vector unsigned short s7 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 7); +} + +vector unsigned short s21 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 21); +} + +vector unsigned short s30 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector unsigned short ms3 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 3); +} + +vector unsigned short ms7 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 7); +} + +vector unsigned short ms21 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 21); +} + +vector unsigned short ms30 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned short ci (vector unsigned short v, int i, unsigned short x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned short mci (vector unsigned short *vp, int i, unsigned short x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, unsigned short *argv[]) { + vector unsigned short sv = { + CONST0, CONST1, CONST2, CONST3, CONST4, CONST5, CONST6, CONST7 }; + + sv = s3 (sv, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = s7 (sv, CONST2); + if (sv [7] != CONST2) + abort (); + + sv = s21 (sv, CONST3); + if (sv [5] != CONST3) + abort (); + + sv = s30 (sv, CONST4); + if (sv [6] != CONST4) + abort (); + + sv = ms3 (&sv, CONST5); + if (sv [3] != CONST5) + abort (); + + sv = ms7 (&sv, CONST6); + if (sv [7] != CONST6) + abort (); + + sv = ms21 (&sv, CONST7); + if (sv [5] != CONST7) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [6] != CONST0) + abort (); + + sv = ci (sv, 5, CONST1); + if (sv [5] != CONST1) + abort (); + + sv = ci (sv, 2, CONST3); + if (sv [2] != CONST3) + abort (); + + sv = ci (sv, 15, CONST2); + if (sv [7] != CONST2) + abort (); + + sv = ci (sv, 28, CONST5); + if (sv [4] != CONST5) + abort (); + + sv = mci (&sv, 5, CONST4); + if (sv [5] != CONST4) + abort (); + + sv = mci (&sv, 12, CONST6); + if (sv [4] != CONST6) + abort (); + + sv = mci (&sv, 25, CONST7); + if (sv [1] != CONST7) + abort (); + + sv = mci (&sv, 16, CONST4); + if (sv [0] != CONST4) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-17d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-17d.c new file mode 100644 index 00000000000..b95dbcdde15 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-17d.c @@ -0,0 +1,154 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned short s3 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 3); +} + +vector unsigned short s7 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 7); +} + +vector unsigned short s21 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 21); +} + +vector unsigned short s30 (vector unsigned short v, unsigned short x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector unsigned short ms3 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 3); +} + +vector unsigned short ms7 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 7); +} + +vector unsigned short ms21 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 21); +} + +vector unsigned short ms30 (vector unsigned short *vp, unsigned short x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned short ci (vector unsigned short v, int i, unsigned short x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned short mci (vector unsigned short *vp, int i, unsigned short x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, unsigned short *argv[]) { + vector unsigned short sv = { + CONST0, CONST1, CONST2, CONST3, CONST4, CONST5, CONST6, CONST7 }; + + sv = s3 (sv, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = s7 (sv, CONST2); + if (sv [7] != CONST2) + abort (); + + sv = s21 (sv, CONST3); + if (sv [5] != CONST3) + abort (); + + sv = s30 (sv, CONST4); + if (sv [6] != CONST4) + abort (); + + sv = ms3 (&sv, CONST5); + if (sv [3] != CONST5) + abort (); + + sv = ms7 (&sv, CONST6); + if (sv [7] != CONST6) + abort (); + + sv = ms21 (&sv, CONST7); + if (sv [5] != CONST7) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [6] != CONST0) + abort (); + + sv = ci (sv, 5, CONST1); + if (sv [5] != CONST1) + abort (); + + sv = ci (sv, 2, CONST3); + if (sv [2] != CONST3) + abort (); + + sv = ci (sv, 15, CONST2); + if (sv [7] != CONST2) + abort (); + + sv = ci (sv, 28, CONST5); + if (sv [4] != CONST5) + abort (); + + sv = mci (&sv, 5, CONST4); + if (sv [5] != CONST4) + abort (); + + sv = mci (&sv, 12, CONST6); + if (sv [4] != CONST6) + abort (); + + sv = mci (&sv, 25, CONST7); + if (sv [1] != CONST7) + abort (); + + sv = mci (&sv, 16, CONST4); + if (sv [0] != CONST4) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-18c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-18c.c new file mode 100644 index 00000000000..19932629d4b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-18c.c @@ -0,0 +1,148 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Unsigned Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned int s3 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 3); +} + +vector unsigned int s1 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 1); +} + +vector unsigned int s21 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 21); +} + +vector unsigned int s30 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector unsigned int ms3 (vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 3); +} + +vector unsigned int ms1(vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 1); +} + +vector unsigned int ms21(vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 21); +} + +vector unsigned int ms30(vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned int ci (vector unsigned int v, int i, unsigned int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned int mci(vector unsigned int *vp, int i, unsigned int x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, unsigned char *argv[]) { + vector unsigned int sv = { CONST0, CONST1, CONST2, CONST3 }; + + sv = s3 (sv, CONST2); + if (sv [3] != CONST2) + abort (); + + sv = s1 (sv, CONST2); + if (sv [1] != CONST2) + abort (); + + sv = s21 (sv, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = s30 (sv, CONST1); + if (sv [2] != CONST1) + abort (); + + sv = ms3 (&sv, CONST0); + if (sv [3] != CONST0) + abort (); + + sv = ms1 (&sv, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = ms21 (&sv, CONST1); + if (sv [1] != CONST1) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [2] != CONST0) + abort (); + + sv = ci (sv, 5, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = ci (sv, 2, CONST0); + if (sv [2] != CONST0) + abort (); + + sv = ci (sv, 15, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = ci (sv, 28, CONST3); + if (sv [0] != CONST3) + abort (); + + sv = mci (&sv, 5, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = mci (&sv, 12, CONST2); + if (sv [0] != CONST2) + abort (); + + sv = mci (&sv, 25, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = mci (&sv, 16, CONST1); + if (sv [0] != CONST1) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-18d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-18d.c new file mode 100644 index 00000000000..8c643aaafd3 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-18d.c @@ -0,0 +1,148 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec -O3" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Unsigned Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned int s3 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 3); +} + +vector unsigned int s1 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 1); +} + +vector unsigned int s21 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 21); +} + +vector unsigned int s30 (vector unsigned int v, unsigned int x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector unsigned int ms3 (vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 3); +} + +vector unsigned int ms1(vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 1); +} + +vector unsigned int ms21(vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 21); +} + +vector unsigned int ms30(vector unsigned int *vp, unsigned int x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned int ci (vector unsigned int v, int i, unsigned int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned int mci(vector unsigned int *vp, int i, unsigned int x) +{ + return vec_insert (x, *vp, i); +} + + +int main (int argc, unsigned char *argv[]) { + vector unsigned int sv = { CONST0, CONST1, CONST2, CONST3 }; + + sv = s3 (sv, CONST2); + if (sv [3] != CONST2) + abort (); + + sv = s1 (sv, CONST2); + if (sv [1] != CONST2) + abort (); + + sv = s21 (sv, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = s30 (sv, CONST1); + if (sv [2] != CONST1) + abort (); + + sv = ms3 (&sv, CONST0); + if (sv [3] != CONST0) + abort (); + + sv = ms1 (&sv, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = ms21 (&sv, CONST1); + if (sv [1] != CONST1) + abort (); + + sv = ms30 (&sv, CONST0); + if (sv [2] != CONST0) + abort (); + + sv = ci (sv, 5, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = ci (sv, 2, CONST0); + if (sv [2] != CONST0) + abort (); + + sv = ci (sv, 15, CONST1); + if (sv [3] != CONST1) + abort (); + + sv = ci (sv, 28, CONST3); + if (sv [0] != CONST3) + abort (); + + sv = mci (&sv, 5, CONST0); + if (sv [1] != CONST0) + abort (); + + sv = mci (&sv, 12, CONST2); + if (sv [0] != CONST2) + abort (); + + sv = mci (&sv, 25, CONST3); + if (sv [1] != CONST3) + abort (); + + sv = mci (&sv, 16, CONST1); + if (sv [0] != CONST1) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-19c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-19c.c new file mode 100644 index 00000000000..3ff0dfe20b0 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-19c.c @@ -0,0 +1,122 @@ +/* { 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. */ + +#include + +extern void abort (void); + +#define CONST0 (31415926539LL) +#define CONST1 (2 * 31415926539LL) +#define CONST2 (3 * 31415926539LL) +#define CONST3 (4 * 31415926539LL) +#define CONST4 (5 * 31415926539LL) +#define CONST5 (6 * 31415926539LL) +#define CONST6 (7 * 31415926539LL) +#define CONST7 (8 * 31415926539LL) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned long long int +e0 (vector unsigned long long int v, unsigned long long int x) +{ + return vec_insert (x, v, 0); +} + +vector unsigned long long int +e3 (vector unsigned long long int v, unsigned long long int x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector unsigned long long int +me0 (vector unsigned long long int *vp, unsigned long long int x) +{ + return vec_insert (x, *vp, 0); +} + +vector unsigned long long int +me3 (vector unsigned long long int *vp, unsigned long long int x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned long long int +ei (vector unsigned long long int v, int i, unsigned long long int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned long long int +mei (vector unsigned long long int *vp, int i, unsigned long long int x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector unsigned long long int dv = { CONST0, CONST1 }; + unsigned long long int d; + + dv = e0 (dv, CONST7); + if (dv [0] != CONST7) + abort (); + + dv = e3 (dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = me0 (&dv, CONST4); + if (dv [0] != CONST4) + abort (); + + dv = me3 (&dv, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = ei (dv, 0, CONST5); + if (dv [0] != CONST5) + abort (); + + dv = ei (dv, 1, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = ei (dv, 2, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 3, CONST6); + if (dv [1] != CONST6) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = mei (&dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 3, CONST2); + if (dv [1] != CONST2) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-19d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-19d.c new file mode 100644 index 00000000000..d0236df5308 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-19d.c @@ -0,0 +1,122 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx -O3" } */ + +/* 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. */ + +#include + +extern void abort (void); + +#define CONST0 (31415926539LL) +#define CONST1 (2 * 31415926539LL) +#define CONST2 (3 * 31415926539LL) +#define CONST3 (4 * 31415926539LL) +#define CONST4 (5 * 31415926539LL) +#define CONST5 (6 * 31415926539LL) +#define CONST6 (7 * 31415926539LL) +#define CONST7 (8 * 31415926539LL) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned long long int +e0 (vector unsigned long long int v, unsigned long long int x) +{ + return vec_insert (x, v, 0); +} + +vector unsigned long long int +e3 (vector unsigned long long int v, unsigned long long int x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector unsigned long long int +me0 (vector unsigned long long int *vp, unsigned long long int x) +{ + return vec_insert (x, *vp, 0); +} + +vector unsigned long long int +me3 (vector unsigned long long int *vp, unsigned long long int x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned long long int +ei (vector unsigned long long int v, int i, unsigned long long int x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned long long int +mei (vector unsigned long long int *vp, int i, unsigned long long int x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector unsigned long long int dv = { CONST0, CONST1 }; + unsigned long long int d; + + dv = e0 (dv, CONST7); + if (dv [0] != CONST7) + abort (); + + dv = e3 (dv, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = me0 (&dv, CONST4); + if (dv [0] != CONST4) + abort (); + + dv = me3 (&dv, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = ei (dv, 0, CONST5); + if (dv [0] != CONST5) + abort (); + + dv = ei (dv, 1, CONST2); + if (dv [1] != CONST2) + abort (); + + dv = ei (dv, 2, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 3, CONST6); + if (dv [1] != CONST6) + abort (); + + dv = mei (&dv, 0, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 1, CONST3); + if (dv [1] != CONST3) + abort (); + + dv = mei (&dv, 2, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 3, CONST2); + if (dv [1] != CONST2) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-20c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-20c.c new file mode 100644 index 00000000000..e56d500515e --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-20c.c @@ -0,0 +1,115 @@ +/* { 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. */ + +#include + +extern void abort (void); + +#define CONST0 (((unsigned __int128) 31415926539) << 60) +#define CONST1 (((unsigned __int128) 31415926539) << 54) +#define CONST2 (((unsigned __int128) 31415926539) << 48) +#define CONST3 (((unsigned __int128) 31415926539) << 32) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned __int128 e0 (vector unsigned __int128 v, unsigned __int128 x) +{ + return vec_insert (x, v, 0); +} + +vector unsigned __int128 e3 (vector unsigned __int128 v, unsigned __int128 x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector unsigned __int128 +me0 (vector unsigned __int128 *vp, unsigned __int128 x) +{ + return vec_insert (x, *vp, 0); +} + +vector unsigned __int128 +me3 (vector unsigned __int128 *vp, unsigned __int128 x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned __int128 +ei (vector unsigned __int128 v, int i, unsigned __int128 x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned __int128 +mei (vector unsigned __int128 *vp, int i, unsigned __int128 x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector unsigned __int128 dv = { CONST0 }; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e3 (dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me0 (&dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me3 (&dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 0, CONST0); + if (dv [0] != CONST0) + abort (); + + dv = ei (dv, 1, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 2, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = ei (dv, 3, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = mei (&dv, 0, CONST0); + if (dv [0] != CONST0) + abort (); + + dv = mei (&dv, 1, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 2, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = mei (&dv, 3, CONST3); + if (dv [0] != CONST3) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-20d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-20d.c new file mode 100644 index 00000000000..17c7b0e48a9 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-20d.c @@ -0,0 +1,115 @@ +/* { dg-do run { target int128 } } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-options "-mvsx -O3" } */ + +/* 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. */ + +#include + +extern void abort (void); + +#define CONST0 (((unsigned __int128) 31415926539) << 60) +#define CONST1 (((unsigned __int128) 31415926539) << 54) +#define CONST2 (((unsigned __int128) 31415926539) << 48) +#define CONST3 (((unsigned __int128) 31415926539) << 32) + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector unsigned __int128 e0 (vector unsigned __int128 v, unsigned __int128 x) +{ + return vec_insert (x, v, 0); +} + +vector unsigned __int128 e3 (vector unsigned __int128 v, unsigned __int128 x) +{ + return vec_insert (x, v, 3); +} + +/* Test for vector residing in memory. */ +vector unsigned __int128 +me0 (vector unsigned __int128 *vp, unsigned __int128 x) +{ + return vec_insert (x, *vp, 0); +} + +vector unsigned __int128 +me3 (vector unsigned __int128 *vp, unsigned __int128 x) +{ + return vec_insert (x, *vp, 3); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector unsigned __int128 +ei (vector unsigned __int128 v, int i, unsigned __int128 x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector unsigned __int128 +mei (vector unsigned __int128 *vp, int i, unsigned __int128 x) +{ + return vec_insert (x, *vp, i); +} + +int main (int argc, char *argv[]) { + vector unsigned __int128 dv = { CONST0 }; + + dv = e0 (dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = e3 (dv, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = me0 (&dv, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = me3 (&dv, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = ei (dv, 0, CONST0); + if (dv [0] != CONST0) + abort (); + + dv = ei (dv, 1, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = ei (dv, 2, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = ei (dv, 3, CONST3); + if (dv [0] != CONST3) + abort (); + + dv = mei (&dv, 0, CONST0); + if (dv [0] != CONST0) + abort (); + + dv = mei (&dv, 1, CONST1); + if (dv [0] != CONST1) + abort (); + + dv = mei (&dv, 2, CONST2); + if (dv [0] != CONST2) + abort (); + + dv = mei (&dv, 3, CONST3); + if (dv [0] != CONST3) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-9c.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-9c.c new file mode 100644 index 00000000000..3bec1474954 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-9c.c @@ -0,0 +1,164 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) +#define CONST8 (8) +#define CONST9 (9) +#define CONSTA (10) +#define CONSTB (11) +#define CONSTC (12) +#define CONSTD (13) +#define CONSTE (14) +#define CONSTF (15) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector signed char c0 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 0); +} + +vector signed char c9 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 9); +} + +vector signed char c21 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 21); +} + +vector signed char c30 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector signed char mc0 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 0); +} + +vector signed char mc9 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 9); +} + +vector signed char mc21 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 21); +} + +vector signed char mc30 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector signed char ci (vector signed char v, int i, signed char x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector signed char mci(vector signed char *vp, int i, signed char x) { + return vec_insert (x, *vp, i); +} + + +int main (int argc, char *argv[]) { + vector signed char cv = { CONST0, CONST1, CONST2, CONST3, + CONST4, CONST5, CONST6, CONST7, + CONST8, CONST9, CONSTA, CONSTB, + CONSTC, CONSTD, CONSTE, CONSTF }; + signed char c; + + cv = c0 (cv, CONSTF); + if (cv [0] != CONSTF) + abort (); + + cv = c9 (cv, CONST7); + if (cv [9] != CONST7) + abort (); + + cv = c21 (cv, CONSTA); + if (cv [5] != CONSTA) + abort (); + + cv = c30 (cv, CONSTC); + if (cv [14] != CONSTC) + abort (); + + cv = mc0 (&cv, CONSTB); + if (cv [0] != CONSTB) + abort (); + + cv = mc9 (&cv, CONST1); + if (cv [9] != CONST1) + abort (); + + cv = mc21 (&cv, CONST7); + if (cv [5] != CONST7) + abort (); + + cv = mc30 (&cv, CONST2); + if (cv [14] != CONST2) + abort (); + + cv = ci (cv, 8, CONST4); + if (cv [8] != CONST4) + abort (); + + cv = ci (cv, 13, CONSTB); + if (cv [13] != CONSTB) + abort (); + + cv = ci (cv, 23, CONST3); + if (cv [7] != CONST3) + abort (); + + cv = ci (cv, 31, CONST2); + if (cv [15] != CONST2) + abort (); + + cv = mci (&cv, 5, CONST1); + if (cv [5] != CONST1) + abort (); + + cv = mci (&cv, 12, CONST3); + if (cv [12] != CONST3) + abort (); + + cv = mci (&cv, 25, CONST5); + if (cv [9] != CONST5) + abort (); + + cv = mci (&cv, 16, CONSTD); + if (cv [0] != CONSTD) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-builtin-9d.c b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-9d.c new file mode 100644 index 00000000000..1e70c521fec --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-builtin-9d.c @@ -0,0 +1,164 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vmx_hw } */ +/* { dg-options "-maltivec -O3" } */ + +/* This test should run the same on any target that supports altivec/vmx + instructions. Intentionally not specifying cpu in order to test + all code generation paths. */ + +#include + +extern void abort (void); + +#define CONST0 (0) +#define CONST1 (1) +#define CONST2 (2) +#define CONST3 (3) +#define CONST4 (4) +#define CONST5 (5) +#define CONST6 (6) +#define CONST7 (7) +#define CONST8 (8) +#define CONST9 (9) +#define CONSTA (10) +#define CONSTB (11) +#define CONSTC (12) +#define CONSTD (13) +#define CONSTE (14) +#define CONSTF (15) + + +/* Test that indices > length of vector are applied modulo the vector + length. */ + +/* Test for vector residing in register. */ +vector signed char c0 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 0); +} + +vector signed char c9 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 9); +} + +vector signed char c21 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 21); +} + +vector signed char c30 (vector signed char v, signed char x) +{ + return vec_insert (x, v, 30); +} + +/* Test for vector residing in memory. */ +vector signed char mc0 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 0); +} + +vector signed char mc9 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 9); +} + +vector signed char mc21 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 21); +} + +vector signed char mc30 (vector signed char *vp, signed char x) +{ + return vec_insert (x, *vp, 30); +} + +/* Test the same with variable indices. */ + +/* Test for variable selector and vector residing in register. */ +__attribute__((noinline)) +vector signed char ci (vector signed char v, int i, signed char x) +{ + return vec_insert (x, v, i); +} + +/* Test for variable selector and vector residing in memory. */ +__attribute__((noinline)) +vector signed char mci(vector signed char *vp, int i, signed char x) { + return vec_insert (x, *vp, i); +} + + +int main (int argc, char *argv[]) { + vector signed char cv = { CONST0, CONST1, CONST2, CONST3, + CONST4, CONST5, CONST6, CONST7, + CONST8, CONST9, CONSTA, CONSTB, + CONSTC, CONSTD, CONSTE, CONSTF }; + signed char c; + + cv = c0 (cv, CONSTF); + if (cv [0] != CONSTF) + abort (); + + cv = c9 (cv, CONST7); + if (cv [9] != CONST7) + abort (); + + cv = c21 (cv, CONSTA); + if (cv [5] != CONSTA) + abort (); + + cv = c30 (cv, CONSTC); + if (cv [14] != CONSTC) + abort (); + + cv = mc0 (&cv, CONSTB); + if (cv [0] != CONSTB) + abort (); + + cv = mc9 (&cv, CONST1); + if (cv [9] != CONST1) + abort (); + + cv = mc21 (&cv, CONST7); + if (cv [5] != CONST7) + abort (); + + cv = mc30 (&cv, CONST2); + if (cv [14] != CONST2) + abort (); + + cv = ci (cv, 8, CONST4); + if (cv [8] != CONST4) + abort (); + + cv = ci (cv, 13, CONSTB); + if (cv [13] != CONSTB) + abort (); + + cv = ci (cv, 23, CONST3); + if (cv [7] != CONST3) + abort (); + + cv = ci (cv, 31, CONST2); + if (cv [15] != CONST2) + abort (); + + cv = mci (&cv, 5, CONST1); + if (cv [5] != CONST1) + abort (); + + cv = mci (&cv, 12, CONST3); + if (cv [12] != CONST3) + abort (); + + cv = mci (&cv, 25, CONST5); + if (cv [9] != CONST5) + abort (); + + cv = mci (&cv, 16, CONSTD); + if (cv [0] != CONSTD) + abort (); + + return 0; +} -- 2.30.2