+2017-12-07 Carl Love <cel@us.ibm.com>
+
+ * gcc.target/powerpc/altivec-12.c (main): Add tests for vec_avg.
+ * gcc.target/powerpc/builtins-1.c: Renamed builtins-1.h.
+ * gcc.target/powerpc/builtins-1.h: Add tests for vec_and,
+ vec_andc, vec_cpsgn, vec_mergeh,vec_mergel, vec_nor, vec_or,
+ vec_sel, vec_xor, vec_all_eq, vec_all_ge, vec_all_gt, vec_all_le,
+ vec_all_lt, vec_all_ne, vec_any_eq,vec_any_ge, vec_any_gt,vec_any_le,
+ vec_any_lt, vec_any_ne, vec_cntlz, vec_round, vec_rsqrt, vec_rsqrte,
+ vec_splat, vec_div, vec_mul,vec_ctf, vec_cts, vec_ctu.
+ * gcc.target/powerpc/builtins-1-be.c: New file, big endian
+ test file for tests in builtins-1.h.
+ * gcc.target/powerpc/builtins-1-le.c: New file, little endian
+ test file for tests in builtins-1.h.
+ * gcc.target/powerpc/builtins-2.c (main): Add tests for vec_ctf,
+ vec_cts, vec_ctu.
+ * gcc.target/powerpc/builtins-3-runnable.c (test_result_sp): Fix printf
+ conversion character.
+ * gcc.target/powerpc/fold-vec-minmax-char.c (test1_min, test2_min,
+ test4_min, test1_max, test2_max): Add tests for vec_max and vec_min.
+ * gcc.target/powerpc/fold-vec-minmax-int.c (test4_min, test5_min,
+ test7_min, test8_min): Add tests for vec_min.
+ * gcc.target/powerpc/fold-vec-minmax-longlong.c (test7_max, test8_max,
+ test9_max, test10_max): Add tests for and vec_max.
+ * gcc.target/powerpc/fold-vec-minmax-short.c (test4_min, test5_min,
+ tes7_min, test8_min): Add tests for and vec_min.
+ * gcc.target/powerpc/p8vector-builtin-8.c (foo): Add test for vec_adds,
+ vec_subs, vec_sum2s, vec_sum4s.
+ * gcc.target/powerpc/vsx-splats-p8.c: New file to test vec_splats.
+ * gcc.target/vsx-vector-5.c (arg1_tests_d, arg1_tests_d): Add
+ tests for vec_ceil, vec_floor, vec_nearbyint, vec_sqrt.
+ * gcc.target/vsx-vector-7.c (foo): Add tests for vec_sel.
+ * gcc.target/vsx-vector-abss.c: New file to test vec_abss.
+
2017-12-11 Carl Love <cel@us.ibm.com>
* config/rs6000/altivec.h (vec_extract_fp32_from_shorth,
/* Program to test PowerPC AltiVec instructions. */
#include <altivec.h>
+#include <stdio.h>
extern void abort (void);
#define CHECK_IF(E) if(!(E)) abort()
+vector char sca = {0,4,8,1,5,9,2,6,10,3,7,11,15,12,14,13};
+vector char scb = {6,4,8,3,1,9,2,6,10,3,7,11,15,12,14,13};
+vector char sc_expected = {3,4,8,2,3,9,2,6,10,3,7,11,15,12,14,13};
+vector char scz;
+vector unsigned char uca = {0,4,8,1,5,9,2,6,10,3,7,11,15,12,14,13};
+vector unsigned char ucb = {6,4,8,3,1,9,2,6,10,3,7,11,15,12,14,13};
+vector unsigned char uc_expected = {3,4,8,2,3,9,2,6,10,3,7,11,15,12,14,13};
+vector char ucz;
+
+vector short int ssia = {9, 16, 25, 36};
+vector short int ssib = {-8, -27, -64, -125};
+vector short int ssiz;
+
+vector short unsigned int ssua = {9, 16, 25, 36};
+vector short unsigned int ssub = {8, 27, 64, 125};
+vector short unsigned int ssuz;
+
+vector unsigned int uia = {22, 13, 24, 39};
+vector unsigned int uib = {8, 7, 4, 15};
+vector unsigned int ui_expected = {15, 10, 14, 27};
+vector unsigned int uiz;
+
vector int a1 = (vector int){ 100, 200, 300, 400 };
vector int a2 = (vector int){ 500, 600, 700, 800 };
vector int addi = (vector int){ 600, 800, 1000, 1200 };
vector int k;
vector float f, g, h;
+int i;
+
int main ()
{
+
k = vec_add (a1, a2);
CHECK_IF (vec_all_eq (addi, k));
CHECK_IF (vec_all_ge (addi, k));
CHECK_IF (!vec_any_lt (addi, k));
CHECK_IF (!vec_any_gt (addi, k));
+ ssiz = vec_avg (ssia, ssib);
+ ssuz = vec_avg (ssua, ssub);
k = vec_avg (a1, a2);
+ scz = vec_avg (sca, scb);
+
+ for (i=0; i< 16; i++)
+ if (scz[i] != sc_expected[i])
+ abort ();
+
+ ucz = vec_avg (uca, ucb);
+
+ for (i=0; i<16; i++)
+ if (ucz[i] != uc_expected[i])
+ abort ();
+
+ uiz = vec_avg (uia, uib);
+
+ for (i=0; i< 4; i++)
+ if (uiz[i] != ui_expected[i])
+ abort ();
+
CHECK_IF (vec_all_eq (k, avgi));
h = vec_add (f1, f2);
--- /dev/null
+/* { dg-do compile { target { powerpc64-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8 -O0" } */
+
+/* Test that a number of newly added builtin overloads are accepted
+ by the compiler. */
+
+/* Expected results for Big Endian:
+ vec_all_eq vcmpequd.
+ vec_all_ne vcmpequd.
+ vec_any_eq vcmpequd.
+ vec_any_ne vcmpequd.
+ vec_all_gt vcmpgtud.
+ vec_all_le vcmpgtud.
+ vec_any_gt vcmpgtud.
+ vec_any_lt vcmpgtud.
+ vec_any_le vcmpgtud.
+ vec_and xxland
+ vec_andc xxlandc
+ vec_cntlz vclzd, vclzb, vclzw, vclzh
+ xvcpsgnsp vec_cpsgn
+ vec_ctf xvmuldp
+ vec_cts xvcvdpsxds, vctsxs
+ vec_ctu xvcvdpuxds, vctuxs
+ vec_div divd, divdu
+ vec_mergel vmrghb, vmrghh, xxmrghw
+ vec_mergeh xxmrglw, vmrglh
+ vec_mul mulld
+ vec_nor xxlnor
+ vec_or xxlor
+ vec_packsu vpksdus
+ vec_perm vperm
+ vec_round xvrdpi
+ vec_sel xxsel
+ vec_xor xxlxor
+ vec_rsqrt xvrsqrtesp
+ vec_rsqrte xvrsqrtesp */
+
+/* { dg-final { scan-assembler-times "vcmpequd." 4 } } */
+/* { dg-final { scan-assembler-times "vcmpgtud." 8 } } */
+/* { dg-final { scan-assembler-times "xxland" 29 } } */
+/* { dg-final { scan-assembler-times "vclzb" 2 } } */
+/* { dg-final { scan-assembler-times "vclzb" 2 } } */
+/* { dg-final { scan-assembler-times "vclzw" 2 } } */
+/* { dg-final { scan-assembler-times "vclzh" 2 } } */
+/* { dg-final { scan-assembler-times "xvcpsgnsp" 1 } } */
+/* { dg-final { scan-assembler-times "xvmuldp" 6 } } */
+/* { dg-final { scan-assembler-times "xvcvdpsxds" 1 } } */
+/* { dg-final { scan-assembler-times "vctsxs" 1 } } */
+/* { dg-final { scan-assembler-times "xvcvdpuxds" 1 } } */
+/* { dg-final { scan-assembler-times "vctuxs" 1 } } */
+/* { dg-final { scan-assembler-times "divd" 4 } } */
+/* { dg-final { scan-assembler-times "divdu" 2 } } */
+/* { dg-final { scan-assembler-times "vmrghb" 0 } } */
+/* { dg-final { scan-assembler-times "vmrghh" 3 } } */
+/* { dg-final { scan-assembler-times "xxmrghw" 1 } } */
+/* { dg-final { scan-assembler-times "xxmrglw" 4 } } */
+/* { dg-final { scan-assembler-times "vmrglh" 4 } } */
+/* { dg-final { scan-assembler-times "mulld" 4 } } */
+/* { dg-final { scan-assembler-times "xxlnor" 19 } } */
+/* { dg-final { scan-assembler-times "xxlor" 14 } } */
+/* { dg-final { scan-assembler-times "vpksdus" 1 } } */
+/* { dg-final { scan-assembler-times "vperm" 2 } } */
+/* { dg-final { scan-assembler-times "xvrdpi" 1 } } */
+/* { dg-final { scan-assembler-times "xxsel" 6 } } */
+/* { dg-final { scan-assembler-times "xxlxor" 6 } } */
+
+/* The source code for the test is in builtins-1.h. */
+#include "builtins-1.h"
+
--- /dev/null
+/* { dg-do compile { target { powerpc64le-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8 -O0" } */
+
+/* Test that a number of newly added builtin overloads are accepted
+ by the compiler. */
+
+/* Expected results for Little Endian:
+ vec_all_eq vcmpequd.
+ vec_all_ne vcmpequd.
+ vec_any_eq vcmpequd.
+ vec_any_ne vcmpequd.
+ vec_all_gt vcmpgtud.
+ vec_all_le vcmpgtud.
+ vec_any_gt vcmpgtud.
+ vec_any_lt vcmpgtud.
+ vec_any_le vcmpgtud.
+ vec_and xxland
+ vec_andc xxlandc
+ vec_cntlz vclzd, vclzb, vclzw, vclzh
+ xvcpsgnsp vec_cpsgn
+ vec_ctf xvmuldp
+ vec_cts xvcvdpsxds, vctsxs
+ vec_ctu xvcvdpuxds, vctuxs
+ vec_div divd, divdu
+ vec_mergel vmrghb, vmrghh, xxmrghw
+ vec_mergeh xxmrglw, vmrglh
+ vec_mul mulld
+ vec_nor xxlnor
+ vec_or xxlor
+ vec_packsu vpksdus
+ vec_perm vperm
+ vec_round xvrdpi
+ vec_sel xxsel
+ vec_xor xxlxor
+ vec_rsqrt xvrsqrtesp
+ vec_rsqrte xvrsqrtesp */
+
+/* { dg-final { scan-assembler-times "vcmpequd." 4 } } */
+/* { dg-final { scan-assembler-times "vcmpgtud." 8 } } */
+/* { dg-final { scan-assembler-times "xxland" 29 } } */
+/* { dg-final { scan-assembler-times "vclzb" 2 } } */
+/* { dg-final { scan-assembler-times "vclzb" 2 } } */
+/* { dg-final { scan-assembler-times "vclzw" 2 } } */
+/* { dg-final { scan-assembler-times "vclzh" 2 } } */
+/* { dg-final { scan-assembler-times "xvcpsgnsp" 1 } } */
+/* { dg-final { scan-assembler-times "xvmuldp" 6 } } */
+/* { dg-final { scan-assembler-times "xvcvdpsxds" 1 } } */
+/* { dg-final { scan-assembler-times "vctsxs" 1 } } */
+/* { dg-final { scan-assembler-times "xvcvdpuxds" 1 } } */
+/* { dg-final { scan-assembler-times "vctuxs" 1 } } */
+/* { dg-final { scan-assembler-times "divd" 4 } } */
+/* { dg-final { scan-assembler-times "divdu" 2 } } */
+/* { dg-final { scan-assembler-times "vmrghb" 3 } } */
+/* { dg-final { scan-assembler-times "vmrghh" 4 } } */
+/* { dg-final { scan-assembler-times "xxmrghw" 4 } } */
+/* { dg-final { scan-assembler-times "xxmrglw" 1 } } */
+/* { dg-final { scan-assembler-times "vmrglh" 3 } } */
+/* { dg-final { scan-assembler-times "mulld" 4 } } */
+/* { dg-final { scan-assembler-times "xxlnor" 19 } } */
+/* { dg-final { scan-assembler-times "xxlor" 14 } } */
+/* { dg-final { scan-assembler-times "vpksdus" 1 } } */
+/* { dg-final { scan-assembler-times "vperm" 2 } } */
+/* { dg-final { scan-assembler-times "xvrdpi" 1 } } */
+/* { dg-final { scan-assembler-times "xxsel" 6 } } */
+/* { dg-final { scan-assembler-times "xxlxor" 6 } } */
+
+/* The test code is in builtins -1.h. */
+#include "builtins-1.h"
-/* { dg-do compile { target { powerpc64le-*-* } } } */
-/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
-/* { dg-options "-mcpu=power8 -O0" } */
-
-/* Test that a number of newly added builtin overloads are accepted
- by the compiler. */
-
+/* This test is included into builtins-1-be.c and builtins-1-le.c to test on
+ Big Endian and Little Endian machines. */
+
#include <altivec.h>
vector double y = { 2.0, 4.0 };
{
vector float fa = {1.0, 2.0, 3.0, -4.0};
vector float fb = {-2.0, -3.0, -4.0, -5.0};
+ vector float fd = vec_and (fa, fb);
vector float fc = vec_cpsgn (fa, fb);
+ vector float fe = vec_mergeh (fa, fb);
+ vector float ff = vec_mergel (fa, fb);
+
+ vector double da = {1.0, 2.0};
+ vector double db = {-2.0, -3.0};
+ vector double dz = vec_and (da, db);
vector long long la = {5L, 14L};
vector long long lb = {3L, 86L};
vector long long lg = vec_andc (la, lb);
vector long long lh = vec_andc (la, ld);
vector long long li = vec_andc (ld, lb);
-
+
vector unsigned long long ug = vec_andc (ua, ub);
vector unsigned long long uh = vec_andc (ua, ud);
vector unsigned long long ui = vec_andc (ud, ub);
- vector double da = {1.0, -4.0};
- vector double db = {-2.0, 5.0};
- vector double dc = vec_cpsgn (da, db);
+ vector double de = {1.0, -4.0};
+ vector double df = {-2.0, 5.0};
+ vector double dg = vec_cpsgn (de, df);
+ vector double dzw = vec_mergeh (de, df);
+ vector double dze = vec_mergel (de, df);
vector long long lj = vec_mergeh (la, lb);
vector long long lk = vec_mergeh (la, ld);
vector unsigned long long uk = vec_mergeh (ua, ud);
vector unsigned long long ul = vec_mergeh (ud, ua);
+ vector pixel pa = {9, 16, 25, 36, 1, 2, 3, 4};
+ vector pixel pb = {25, 36, 1, 2, 45, 3, 4, 99};
+ vector pixel pc = vec_mergeh (pa, pb);
+ vector pixel pd = vec_mergel (pa, pb);
+
vector long long lm = vec_mergel (la, lb);
vector long long ln = vec_mergel (la, ld);
vector long long lo = vec_mergel (ld, la);
vector unsigned long long uu = vec_or (ud, ua);
vector unsigned char ca = {0,4,8,1,5,9,2,6,10,3,7,11,15,12,14,13};
+ vector unsigned char cbb = {5,4,8,3,1,9,2,6,10,3,7,11,15,12,14,13};
+
vector long long lv = vec_perm (la, lb, ca);
+
+ vector unsigned char ucm = vec_and (ca, cbb);
+ vector unsigned char ucn = vec_andc (ca, cbb);
+ vector unsigned char uco = vec_mergel (ca, cbb);
+
vector unsigned long long uv = vec_perm (ua, ub, ca);
vector long long lw = vec_sel (la, lb, lc);
int il = vec_any_lt (ua, ub);
int im = vec_any_ne (ua, ub);
+ vector short ssa = {9, 16, 25, 36, 1, 2, 3, 4};
+ vector short ssb = {-8, -27, -64, -125, 2, 3, 5, 3};
+ vector short sscc = vec_and (ssa, ssb);
+ vector short sscd = vec_mergeh (ssa, ssb);
+ vector short ssce = vec_mergel (ssa, ssb);
+
vector int sia = {9, 16, 25, 36};
vector int sib = {-8, -27, -64, -125};
- vector int sic = vec_mergee (sia, sib);
- vector int sid = vec_mergeo (sia, sib);
+ vector int sicc = vec_and (sia, sib);
+ vector int sicd = vec_andc (sia, sib);
+ vector int sig = vec_mergel (sia, sib);
vector unsigned int uia = {9, 16, 25, 36};
vector unsigned int uib = {8, 27, 64, 125};
- vector unsigned int uic = vec_mergee (uia, uib);
- vector unsigned int uid = vec_mergeo (uia, uib);
+ vector unsigned int uicc = vec_and (uia, uib);
+ vector unsigned int uidd = vec_andc (uia, uib);
+ vector unsigned int uig = vec_mergel (uia, uib);
+
+ vector bool char bca = {0, 1, 4, 7};
+ vector bool char bcb = {-8, 9, 2, 9};
+ vector bool char bcc = vec_and (bca, bcb);
+ vector bool char bcd = vec_andc (bca, bcb);
+ vector bool char bce = vec_mergel (bca, bcb);
+
+ vector bool short bsa = {0, -1, -1, 0, 3, 4, 6, 7};
+ vector bool short bsb = {-1, -1, 0, -1, 0, 0, 0, 0};
+ vector bool short bscc = vec_and (bsa, bsb);
+ vector bool short bscd = vec_andc (bsa, bsb);
+ vector bool short bsce = vec_mergel (bsa, bsb);
vector bool int bia = {0, -1, -1, 0};
vector bool int bib = {-1, -1, 0, -1};
- vector bool int bic = vec_mergee (bia, bib);
- vector bool int bid = vec_mergeo (bia, bib);
+ vector bool int bicc = vec_and (bia, bib);
+ vector bool int bicd = vec_andc (bia, bib);
+ vector bool int bide = vec_mergel (bia, bib);
vector unsigned int uie = vec_packsu (ua, ub);
vector unsigned long long u2 = vec_cntlz (ua);
vector int sie = vec_cntlz (sia);
vector unsigned int uif = vec_cntlz (uia);
- vector short ssa = {20, -40, -60, 80, 100, -120, -140, 160};
- vector short ssb = vec_cntlz (ssa);
+ vector short sszz = vec_cntlz (ssa);
+
vector unsigned short usa = {81, 72, 63, 54, 45, 36, 27, 18};
- vector unsigned short usb = vec_cntlz (usa);
+ vector unsigned short usb = {81, 72, 63, 54, 45, 36, 27, 18};
+ vector unsigned short usd = vec_and (usa, usb);
+ vector unsigned short use = vec_andc (usa, usb);
+ vector unsigned short usc = vec_cntlz (usa);
+ vector unsigned short uscd = vec_mergeh (usa, usb);
+ vector unsigned short usce = vec_mergel (usa, usb);
+
vector signed char sca = {-4, 3, -9, 15, -31, 31, 0, 0,
1, 117, -36, 99, 98, 97, 96, 95};
vector signed char scb = vec_cntlz (sca);
+ vector signed char scc = vec_mergel (sca, scb);
+
vector unsigned char cb = vec_cntlz (ca);
vector double dd = vec_xl (0, &y);
vec_xst (dd, 0, &z);
- vector double de = vec_round (dd);
+ vector double dzz = vec_round (dd);
+ vector double dzz1 = vec_rsqrt (dd);
+ vector double dzz2 = vec_rsqrte (dd);
- vector double df = vec_splat (de, 0);
- vector double dg = vec_splat (de, 1);
+ vector double dff = vec_splat (de, 0);
+ vector double dgg = vec_splat (de, 1);
vector long long l3 = vec_splat (l2, 0);
vector long long l4 = vec_splat (l2, 1);
vector unsigned long long u3 = vec_splat (u2, 0);
vector double dh = vec_ctf (la, -2);
vector double di = vec_ctf (ua, 2);
+ vector int sz = vec_cts (fa, 0x1F);
vector long long l9 = vec_cts (dh, -2);
vector unsigned long long u7 = vec_ctu (di, 2);
+ vector unsigned int usz = vec_ctu (fa, 0x1F);
return 0;
}
-/* { dg-do run { target { powerpc64le-*-* } } } */
+/* { dg-do run { target { powerpc*-*-* } } } */
/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
/* { dg-options "-mcpu=power8 " } */
#include <altivec.h>
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
void abort (void);
int main ()
{
+ vector int inta = {27, -1, 4, 9};
+ vector unsigned int uinta = {9, 0, 7, 222};
+
vector long long sa = {27L, -14L};
vector long long sb = {-9L, -2L};
|| sg[0] != 27L || sg[1] != -14L || ug[0] != 27L || ug[1] != 14L)
abort ();
+ vector float fa = vec_ctf (inta, 5);
+ if (fa[0] != 0.843750 || fa[1] != -0.031250 || fa[2] != 0.125000 || fa[3] != 0.281250)
+#ifdef DEBUG
+ printf("fa[0] = %f, fa[1] = %f, fa[2] = %f, fa[3] = %f\n",
+ fa[0], fa[1], fa[2], fa[3]);
+#else
+ abort ();
+#endif
+
+ vector int sa2 = vec_cts (fa, 5);
+ if (sa2[0] != 27 || sa2[1] != -1 || sa2[2] != 4 || sa2[3] != 9)
+#ifdef DEBUG
+ printf("sa2[0] = %d, sa2[1] = %d, sa2[2] = %d, sa2[3] = %d\n",
+ sa2[0], sa2[1], sa2[2], sa2[3]);
+#else
+ abort ();
+#endif
+
+ vector float fb = vec_ctf (uinta, 2);
+
+ if (fb[0] != 2.250000 || fb[1] != 0.0 || fb[2] != 1.750000 || fb[3] != 55.500000)
+#ifdef DEBUG
+ printf("fb[0] = %f, fb[1] = %f, fb[2] = %f, fb[3] = %f\n",
+ fb[0], fb[1], fb[2], fb[3]);
+#else
+ abort ();
+#endif
+
+ vector unsigned int ua2 = vec_ctu (fb, 2);
+ if (ua2[0] != 9 || ua2[1] != 0 || ua2[2] != 7 || ua2[3] != 222)
+#ifdef DEBUG
+ printf("ua2[0] = %d, ua2[1] = %d, ua2[2] = %d, ua2[3] = %d\n",
+ ua2[0], ua2[1], ua2[2], ua2[3]);
+#else
+ abort ();
+#endif
+
return 0;
}
/* { dg-do run { target { powerpc*-*-linux* } } } */
/* { dg-require-effective-target vsx_hw } */
/* { dg-options "-O2 -mvsx -mcpu=power8" } */
-/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=power8" } } */
#include <altivec.h> // vector
if (vec_result[i] != vec_expected[i]) {
#ifdef DEBUG
printf("Test_result_sp: ");
- printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
+ printf("vec_result[%d] (%f) != vec_expected[%d] (%f)\n",
i, vec_result[i], i, vec_expected[i]);
#else
abort();
if (vec_result[0] != vec_expected[0]) {
#ifdef DEBUG
printf("Test_result_dp: ");
- printf("vec_result[0] (%lld) != vec_expected[0] (%lld)\n",
+ printf("vec_result[0] (%f) != vec_expected[0] (%f)\n",
vec_result[0], vec_expected[0]);
#else
abort();
}
vector signed char
-test3_max (vector signed char x, vector signed char y)
+test1_min (vector bool char x, vector signed char y)
+{
+ return vec_min (x, y);
+}
+
+vector unsigned char
+test2_min (vector bool char x, vector unsigned char y)
+{
+ return vec_min (x, y);
+}
+
+vector unsigned char
+test4_min (vector unsigned char x, vector bool char y)
+{
+ return vec_min (x, y);
+}
+
+vector signed char
+test1_max (vector signed char x, vector signed char y)
{
return vec_max (x, y);
}
vector unsigned char
-test6_max (vector unsigned char x, vector unsigned char y)
+test2_max (vector unsigned char x, vector unsigned char y)
{
return vec_max (x, y);
}
-/* { dg-final { scan-assembler-times "vminsb" 1 } } */
+/* { dg-final { scan-assembler-times "vminsb" 2 } } */
/* { dg-final { scan-assembler-times "vmaxsb" 1 } } */
-/* { dg-final { scan-assembler-times "vminub" 1 } } */
+/* { dg-final { scan-assembler-times "vminub" 3 } } */
/* { dg-final { scan-assembler-times "vmaxub" 1 } } */
return vec_max (x, y);
}
-/* { dg-final { scan-assembler-times "vminsw" 1 } } */
+vector signed int
+test4_min (vector bool int x, vector signed int y)
+{
+ return vec_min (x, y);
+}
+
+vector signed int
+test5_min (vector signed int x, vector bool int y)
+{
+ return vec_min (x, y);
+}
+
+vector unsigned int
+test7_min (vector bool int x, vector unsigned int y)
+{
+ return vec_min (x, y);
+}
+
+vector unsigned int
+test8_min (vector unsigned int x, vector bool int y)
+{
+ return vec_min (x, y);
+}
+
+/* { dg-final { scan-assembler-times "vminsw" 3 } } */
/* { dg-final { scan-assembler-times "vmaxsw" 1 } } */
-/* { dg-final { scan-assembler-times "vminuw" 1 } } */
+/* { dg-final { scan-assembler-times "vminuw" 3 } } */
/* { dg-final { scan-assembler-times "vmaxuw" 1 } } */
return vec_max (x, y);
}
+vector signed long long
+test7_max (vector signed long long x, vector long long bool y)
+{
+ return vec_max (x, y);
+}
+
+vector signed long long
+test8_max (vector long long bool x, vector signed long long y)
+{
+ return vec_max (x, y);
+}
+
+vector unsigned long long
+test9_max (vector unsigned long long x, vector long long bool y)
+{
+ return vec_max (x, y);
+}
+
+vector unsigned long long
+test10_max (vector long long bool x, vector unsigned long long y)
+{
+ return vec_max (x, y);
+}
+
/* { dg-final { scan-assembler-times "vminsd" 1 } } */
-/* { dg-final { scan-assembler-times "vmaxsd" 1 } } */
+/* { dg-final { scan-assembler-times "vmaxsd" 3 } } */
/* { dg-final { scan-assembler-times "vminud" 1 } } */
-/* { dg-final { scan-assembler-times "vmaxud" 1 } } */
+/* { dg-final { scan-assembler-times "vmaxud" 3 } } */
return vec_max (x, y);
}
-/* { dg-final { scan-assembler-times "vminsh" 1 } } */
+vector unsigned short
+test4_min (vector bool short x, vector unsigned short y)
+{
+ return vec_min (x, y);
+}
+
+vector unsigned short
+test5_min (vector unsigned short x, vector bool short y)
+{
+ return vec_min (x, y);
+}
+
+vector signed short
+test7_min (vector bool short x, vector signed short y)
+{
+ return vec_min (x, y);
+}
+
+vector signed short
+test8_min (vector signed short x, vector bool short y)
+{
+ return vec_min (x, y);
+}
+
+/* { dg-final { scan-assembler-times "vminsh" 3 } } */
/* { dg-final { scan-assembler-times "vmaxsh" 1 } } */
-/* { dg-final { scan-assembler-times "vminuh" 1 } } */
+/* { dg-final { scan-assembler-times "vminuh" 3 } } */
/* { dg-final { scan-assembler-times "vmaxuh" 1 } } */
/* Test POWER8 vector built-ins added for version 1.1 of ELFv2 ABI. */
+vector signed char vsca, vscb, vscc;
vector unsigned char vuca, vucb, vucc;
+vector signed short vssa, vssb;
vector bool char vbca, vbcb;
vector unsigned short vusa, vusb;
vector bool short vbsa, vbsb;
vector unsigned __int128 vuxa, vuxb, vuxc;
vector double vda, vdb;
-void foo (vector unsigned char *vucr,
+void foo (vector signed char *vscr,
+ vector unsigned char *vucr,
vector bool char *vbcr,
+ vector signed short *vssr,
vector unsigned short *vusr,
vector bool short *vbsr,
vector signed int *vsir,
*vuir++ = vec_addec (vuia, vuib, vuic);
*vsxr++ = vec_addec (vsxa, vsxb, vsxc);
*vuxr++ = vec_addec (vuxa, vuxb, vuxc);
+ *vscr++ = vec_adds (vsca, vscb);
+ *vucr++ = vec_adds (vuca, vucb);
+ *vsir++ = vec_adds (vsia, vsib);
+ *vuir++ = vec_adds (vuia, vuib);
+ *vssr++ = vec_adds (vssa, vssb);
+ *vusr++ = vec_adds (vusa, vusb);
+ *vscr++ = vec_adds (vbca, vscb);
+ *vscr++ = vec_adds (vsca, vbcb);
+ *vucr++ = vec_adds (vbca, vucb);
+ *vucr++ = vec_adds (vuca, vbcb);
+ *vsir++ = vec_adds (vbia, vsib);
+ *vsir++ = vec_adds (vsia, vbib);
+ *vuir++ = vec_adds (vbia, vuib);
+ *vuir++ = vec_adds (vuia, vbib);
+ *vssr++ = vec_adds (vbsa, vssb);
+ *vssr++ = vec_adds (vssa, vbsb);
+ *vusr++ = vec_adds (vbsa, vusb);
+ *vusr++ = vec_adds (vusa, vbsb);
*vucr++ = vec_bperm (vuca, vucb);
*vulr++ = vec_bperm (vuxa, vucb);
*vbcr++ = vec_eqv (vbca, vbcb);
*vuir++ = vec_subec (vuia, vuib, vuic);
*vsxr++ = vec_subec (vsxa, vsxb, vsxc);
*vuxr++ = vec_subec (vuxa, vuxb, vuxc);
+ *vscr++ = vec_subs (vsca, vscb);
+ *vucr++ = vec_subs (vuca, vucb);
+ *vsir++ = vec_subs (vsia, vsib);
+ *vuir++ = vec_subs (vuia, vuib);
+ *vssr++ = vec_subs (vssa, vssb);
+ *vusr++ = vec_subs (vusa, vusb);
+ *vsir++ = vec_sum2s (vsia, vsib);
+ *vsir++ = vec_sum4s (vsca, vsib);
+ *vsir++ = vec_sum4s (vssa, vsib);
+ *vuir++ = vec_sum4s (vuca, vuib);
+
}
/* { dg-final { scan-assembler-times "vaddcuq" 2 } } */
/* { dg-final { scan-assembler-times "vpmsumd" 1 } } */
/* { dg-final { scan-assembler-times "vshasigmaw" 1 } } */
/* { dg-final { scan-assembler-times "vshasigmad" 1 } } */
+/* { dg-final { scan-assembler-times "vsubsbs" 1 } } vec_subs */
+/* { dg-final { scan-assembler-times "vsububs" 1 } } vec_subs */
+/* { dg-final { scan-assembler-times "vsubsws" 1 } } vec_subs */
+/* { dg-final { scan-assembler-times "vsubuws" 1 } } vec_subs */
+/* { dg-final { scan-assembler-times "vsubshs" 1 } } vec_subs */
+/* { dg-final { scan-assembler-times "vsubuhs" 1 } } vec_subs */
+/* { dg-final { scan-assembler-times "vsum2sws" 1 } } vec_sum2s */
+/* { dg-final { scan-assembler-times "vsum4sws" 0 } } vec_sum4s */
+/* { dg-final { scan-assembler-times "vsum4shs" 1 } } vec_sum4s */
+/* { dg-final { scan-assembler-times "vsum4ubs" 1 } } vec_sum4s */
-/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
+/* { dg-do run { target { powerpc*-*-* && lp64 } } } */
/* { dg-skip-if "" { powerpc*-*-darwin* } } */
/* { dg-require-effective-target powerpc_vsx_ok } */
/* { dg-options "-mvsx -O2" } */
static int errors = 0;
#endif
-union args {
+union args_d {
double scalar[2];
vector double vect;
};
+union args_f {
+ float scalar[4];
+ vector float vect;
+};
+
union largs {
unsigned long scalar[2];
vector bool long vect;
};
static void
-do_test (union args *expected, union args *got, const char *name)
+do_test_d (union args_d *expected, union args_d *got, const char *name)
{
if (expected->scalar[0] != got->scalar[0]
|| expected->scalar[1] != got->scalar[1])
}
static void
+do_test_f (union args_f *expected, union args_f *got, const char *name)
+{
+ if (expected->scalar[0] != got->scalar[0]
+ || expected->scalar[1] != got->scalar[1]
+ || expected->scalar[2] != got->scalar[2]
+ || expected->scalar[3] != got->scalar[3])
+ {
+#ifdef DEBUG
+ printf ("%s failed!\n", name);
+ errors++;
+#else
+ abort ();
+#endif
+ }
+}
+
+static void
do_ltest (union largs *expected, union largs *got, const char *name)
{
if (expected->scalar[0] != got->scalar[0]
}
static vector double
-vceil (vector double arg)
+vceil_d (vector double arg)
+{
+ return vec_ceil (arg);
+}
+
+static vector float
+vceil_f (vector float arg)
{
return vec_ceil (arg);
}
static vector double
-vfloor (vector double arg)
+vfloor_d (vector double arg)
+{
+ return vec_floor (arg);
+}
+
+static vector float
+vfloor_f (vector float arg)
{
return vec_floor (arg);
}
static vector double
-vnearbyint (vector double arg)
+vnearbyint_d (vector double arg)
+{
+ return vec_nearbyint (arg);
+}
+
+static vector float
+vnearbyint_f (vector float arg)
{
return vec_nearbyint (arg);
}
return vec_rint (arg);
}
+static vector float
+vsqrt_f (vector float arg)
+{
+ return vec_sqrt (arg);
+}
+
static vector double
-vsqrt (vector double arg)
+vsqrt_d (vector double arg)
{
return vec_sqrt (arg);
}
-/* Single argument tests. */
+/* Single argument tests with double args */
static struct
{
- union args result;
- union args input;
+ union args_d result;
+ union args_d input;
vector double (*func) (vector double);
const char *name;
-} arg1_tests[] = {
+} arg1_tests_d[] = {
/* result input function name */
{ { 1.0, 2.0 }, { -1.0, 2.0 }, vabs, "vabs" },
{ { 1.0, 2.0 }, { 1.0, -2.0 }, vabs, "vabs" },
- { { 2.0, 2.0 }, { 1.1, 1.7 }, vceil, "vceil" },
- { { -1.0, -1.0 }, { -1.1, -1.7 }, vceil, "vceil" },
- { { -1.0, 2.0 }, { -1.5, 1.5 }, vceil, "vceil" },
- { { 1.0, 1.0 }, { 1.1, 1.7 }, vfloor, "vfloor" },
- { { -2.0, -2.0 }, { -1.1, -1.7 }, vfloor, "vfloor" },
- { { -2.0, 1.0 }, { -1.5, 1.5 }, vfloor, "vfloor" },
- { { 1.0, 2.0 }, { 1.1, 1.7 }, vnearbyint, "vnearbyint" },
- { { -1.0, -2.0 }, { -1.1, -1.7 }, vnearbyint, "vnearbyint" },
- { { -2.0, 2.0 }, { -1.5, 1.5 }, vnearbyint, "vnearbyint" },
+ { { 2.0, 2.0 }, { 1.1, 1.7 }, vceil_d, "vceil_d" },
+ { { -1.0, -1.0 }, { -1.1, -1.7 }, vceil_d, "vceil_d" },
+ { { -1.0, 2.0 }, { -1.5, 1.5 }, vceil_d, "vceil_d" },
+ { { 1.0, 1.0 }, { 1.1, 1.7 }, vfloor_d, "vfloor_d" },
+ { { -2.0, -2.0 }, { -1.1, -1.7 }, vfloor_d, "vfloor_d" },
+ { { -2.0, 1.0 }, { -1.5, 1.5 }, vfloor_d, "vfloor_d" },
+ { { 1.0, 2.0 }, { 1.1, 1.7 }, vnearbyint_d, "vnearbyint_d" },
+ { { -1.0, -2.0 }, { -1.1, -1.7 }, vnearbyint_d, "vnearbyint_d" },
+ { { -2.0, 2.0 }, { -1.5, 1.5 }, vnearbyint_d, "vnearbyint_d" },
{ { 1.0, 2.0 }, { 1.1, 1.7 }, vrint, "vrint" },
{ { -1.0, -2.0 }, { -1.1, -1.7 }, vrint, "vrint" },
{ { -2.0, 2.0 }, { -1.5, 1.5 }, vrint, "vrint" },
- { { 2.0, 4.0 }, { 4.0, 16.0 }, vsqrt, "vsqrt" },
+
+ { { 2.0, 4.0 }, { 4.0, 16.0 }, vsqrt_d, "vsqrt_d" },
};
static void
-test_arg1 (void)
+test_arg1_d (void)
{
unsigned i;
#ifdef DEBUG
- printf ("Single argument tests:\n");
+ printf ("\nSingle argument tests with double args:\n");
#endif
- for (i = 0; i < sizeof (arg1_tests) / sizeof (arg1_tests[0]); i++)
+ for (i = 0; i < sizeof (arg1_tests_d) / sizeof (arg1_tests_d[0]); i++)
{
- union args u;
- u.vect = arg1_tests[i].func (arg1_tests[i].input.vect);
+ union args_d u;
+ u.vect = arg1_tests_d[i].func (arg1_tests_d[i].input.vect);
#ifdef DEBUG
printf ("test %-16s: expected { %4g, %4g }, got { %4g, %4g }, input { %4g, %4g }\n",
- arg1_tests[i].name,
- arg1_tests[i].result.scalar[0],
- arg1_tests[i].result.scalar[1],
+ arg1_tests_d[i].name,
+ arg1_tests_d[i].result.scalar[0],
+ arg1_tests_d[i].result.scalar[1],
+ u.scalar[0],
+ u.scalar[1],
+ arg1_tests_d[i].input.scalar[0],
+ arg1_tests_d[i].input.scalar[1]);
+#endif
+
+ do_test_d (&arg1_tests_d[i].result, &u, arg1_tests_d[i].name);
+ }
+
+ return;
+}
+
+/* Single argument tests with float args. */
+static struct
+{
+ union args_f result;
+ union args_f input;
+ vector float (*func) (vector float);
+ const char *name;
+} arg1_tests_f[] = {
+ /* result input function name */
+ { { 2.0, 2.0, 3.0, 3.0 }, { 1.05, 1.1, 2.2, 2.3 }, vceil_f, "vceil_f" },
+ { { -1.0, -1.0, -2.0, -2.0 }, { -1.1, -1.7, -2.1, -2.4 }, vceil_f, "vceil_f" },
+ { { 1.0, 1.0, 2.0, 2.0 }, { 1.05, 1.1, 2.2, 2.3 }, vfloor_f, "vfloor_f" },
+ { { -2.0, -2.0, -3.0, -3.0 }, { -1.1, -1.7, -2.1, -2.4 }, vfloor_f, "vfloor_f" },
+ { { 1.0, 2.0, -3.0, 3.0 }, { 1.1, 1.7, -3.1, 3.1 }, vnearbyint_f, "vnearbyint_f" },
+ { { -1.0, -2.0, -3.0, 3.0 }, { -1.1, -1.7, -2.9, 2.9 }, vnearbyint_f, "vnearbyint_f" },
+ { { -2.0, 2.0, -3.0, 3.0 }, { -1.5, 1.5, -2.55, 3.49 }, vnearbyint_f, "vnearbyint_f" },
+ { { 2.0, 4.0 }, { 4.0, 16.0 }, vsqrt_f, "vsqrt_f" },
+};
+
+static void
+test_arg1_f (void)
+{
+ unsigned i;
+
+#ifdef DEBUG
+ printf ("\nSingle argument tests with float args:\n");
+#endif
+
+ for (i = 0; i < sizeof (arg1_tests_f) / sizeof (arg1_tests_f[0]); i++)
+ {
+ union args_f u;
+ u.vect = arg1_tests_f[i].func (arg1_tests_f[i].input.vect);
+
+#ifdef DEBUG
+ printf ("test %-16s: expected { %4g, %4g, %4g, %4g }, got { %4g, %4g, %4g, %4g }, input { %4g, %4g, %4g, %4g }\n",
+ arg1_tests_f[i].name,
+ arg1_tests_f[i].result.scalar[0],
+ arg1_tests_f[i].result.scalar[1],
+ arg1_tests_f[i].result.scalar[2],
+ arg1_tests_f[i].result.scalar[3],
u.scalar[0],
u.scalar[1],
- arg1_tests[i].input.scalar[0],
- arg1_tests[i].input.scalar[1]);
+ u.scalar[2],
+ u.scalar[3],
+ arg1_tests_f[i].input.scalar[0],
+ arg1_tests_f[i].input.scalar[1],
+ arg1_tests_f[i].input.scalar[2],
+ arg1_tests_f[i].input.scalar[3]);
#endif
- do_test (&arg1_tests[i].result, &u, arg1_tests[i].name);
+ do_test_f (&arg1_tests_f[i].result, &u, arg1_tests_f[i].name);
}
return;
/* 2 argument tests. */
static struct
{
- union args result;
- union args input[2];
+ union args_d result;
+ union args_d input[2];
vector double (*func) (vector double, vector double);
const char *name;
} arg2_tests[] = {
for (i = 0; i < sizeof (arg2_tests) / sizeof (arg2_tests[0]); i++)
{
- union args u;
+ union args_d u;
u.vect = arg2_tests[i].func (arg2_tests[i].input[0].vect,
arg2_tests[i].input[1].vect);
arg2_tests[i].input[1].scalar[1]);
#endif
- do_test (&arg2_tests[i].result, &u, arg2_tests[i].name);
+ do_test_d (&arg2_tests[i].result, &u, arg2_tests[i].name);
}
return;
static struct
{
union largs result;
- union args input[2];
+ union args_d input[2];
vector bool long (*func) (vector double, vector double);
const char *name;
} argcmp_tests[] = {
int
main (int argc, char *argv[])
{
- test_arg1 ();
+ test_arg1_f ();
+ test_arg1_d ();
test_arg2 ();
test_argcmp ();
vector bool long long vbla, vblb, vblc;
vector signed long long vsla;
-vector unsigned long long vula, vulc;
+vector unsigned long long vula, vulb, vulc;
+vector double vda, vdb;
+vector float vfa, vfb;
void foo (vector bool long long *vblr,
- vector double *vdr)
+ vector double *vdr, vector unsigned long long *vulz, vector double *vdz)
{
*vblr++ = vec_andc (vbla, vblb);
*vdr++ = vec_double (vsla);
*vblr++ = vec_sel (vbla, vblb, vblc);
*vblr++ = vec_sel (vbla, vblb, vulc);
*vblr++ = vec_xor (vbla, vblb);
+
+ *vulz++ = vec_sel (vula, vulb, vblc);
+
+ *vdz++ = vec_sel(vda, vdb, vulc);
}
/* { dg-final { scan-assembler-times "xxlandc" 1 } } */
/* { dg-final { scan-assembler-times "xxpermdi .*,.*,.*,0" 1 } } */
/* { dg-final { scan-assembler-times "xxlnor" 1 } } */
/* { dg-final { scan-assembler-times "xxlor" 1 } } */
-/* { dg-final { scan-assembler-times "xxsel" 2 } } */
+/* { dg-final { scan-assembler-times "xxsel" 4 } } */
/* { dg-final { scan-assembler-times "xxlxor" 1 } } */
projects / platform / upstream / gcc.git / commitdiff