Viewing file:  vsx-vector-5.c (12.4 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* { dg-do run { target lp64 } } */
/* { dg-skip-if "" { powerpc*-*-darwin* } } */
/* { dg-require-effective-target powerpc_vsx_ok } */
/* { dg-options "-mvsx -O2" } */
/* This will run, and someday we should add the support to test whether we are
running on VSX hardware. */
#include <altivec.h>
#include <stdlib.h>
#ifdef DEBUG
#include <stdio.h>
static int errors = 0;
#endif
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_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])
{
#ifdef DEBUG
printf ("%s failed!\n", name);
errors++;
#else
abort ();
#endif
}
}
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]
|| expected->scalar[1] != got->scalar[1])
{
#ifdef DEBUG
printf ("%s failed!\n", name);
errors++;
#else
abort ();
#endif
}
}
/* Vec functions taking a single argument. */
static vector double
vabs (vector double arg)
{
return vec_abs (arg);
}
static vector double
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_d (vector double arg)
{
return vec_floor (arg);
}
static vector float
vfloor_f (vector float arg)
{
return vec_floor (arg);
}
static vector double
vnearbyint_d (vector double arg)
{
return vec_nearbyint (arg);
}
static vector float
vnearbyint_f (vector float arg)
{
return vec_nearbyint (arg);
}
static vector float
vrint_f (vector float arg)
{
return vec_rint (arg);
}
static vector double
vrint_d (vector double arg)
{
return vec_rint (arg);
}
static vector float
vsqrt_f (vector float arg)
{
return vec_sqrt (arg);
}
static vector double
vsqrt_d (vector double arg)
{
return vec_sqrt (arg);
}
/* Single argument tests with double args */
static struct
{
union args_d result;
union args_d input;
vector double (*func) (vector double);
const char *name;
} 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_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_d, "vrint_d" },
{ { -1.0, -2.0 }, { -1.1, -1.7 }, vrint_d, "vrint_d" },
{ { -2.0, 2.0 }, { -1.5, 1.5 }, vrint_d, "vrint_d" },
{ { 2.0, 4.0 }, { 4.0, 16.0 }, vsqrt_d, "vsqrt_d" },
};
static void
test_arg1_d (void)
{
unsigned i;
#ifdef DEBUG
printf ("\nSingle argument tests with double args:\n");
#endif
for (i = 0; i < sizeof (arg1_tests_d) / sizeof (arg1_tests_d[0]); i++)
{
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_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" },
{ { 10.0, 18.0, 30.0, 40.0 }, { 10.1, 17.7, 30.0, 40.01 }, vrint_f, "vrint_f" },
{ { -11.0, -18.0, -30.0, -40.0 }, { -11.1, -17.7, -30.0, -40.01 }, vrint_f, "vrint_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],
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_f (&arg1_tests_f[i].result, &u, arg1_tests_f[i].name);
}
return;
}
/* Vect functions taking 2 arguments. */
static vector double
vadd (vector double arg1, vector double arg2)
{
return vec_add (arg1, arg2);
}
static vector double
vadd2 (vector double arg1, vector double arg2)
{
return arg1 + arg2;
}
static vector double
vsub (vector double arg1, vector double arg2)
{
return vec_sub (arg1, arg2);
}
static vector double
vsub2 (vector double arg1, vector double arg2)
{
return arg1 - arg2;
}
static vector double
vmul (vector double arg1, vector double arg2)
{
return vec_mul (arg1, arg2);
}
static vector double
vmul2 (vector double arg1, vector double arg2)
{
return arg1 * arg2;
}
static vector double
vdiv (vector double arg1, vector double arg2)
{
return vec_div (arg1, arg2);
}
static vector double
vdiv2 (vector double arg1, vector double arg2)
{
return arg1 / arg2;
}
static vector double
vmax (vector double arg1, vector double arg2)
{
return vec_max (arg1, arg2);
}
static vector double
vmin (vector double arg1, vector double arg2)
{
return vec_min (arg1, arg2);
}
/* 2 argument tests. */
static struct
{
union args_d result;
union args_d input[2];
vector double (*func) (vector double, vector double);
const char *name;
} arg2_tests[] = {
/* result */
{ { 4.0, 6.0 }, { { 1.0, 2.0 }, { 3.0, 4.0 } }, vadd, "vadd" },
{ { 4.0, -6.0 }, { { 1.0, -2.0 }, { 3.0, -4.0 } }, vadd, "vadd" },
{ { 4.0, 6.0 }, { { 1.0, 2.0 }, { 3.0, 4.0 } }, vadd2, "vadd2" },
{ { 4.0, -6.0 }, { { 1.0, -2.0 }, { 3.0, -4.0 } }, vadd2, "vadd2" },
{ { -2.0, -2.0 }, { { 1.0, 2.0 }, { 3.0, 4.0 } }, vsub, "vsub" },
{ { -2.0, 2.0 }, { { 1.0, -2.0 }, { 3.0, -4.0 } }, vsub, "vsub" },
{ { -2.0, -2.0 }, { { 1.0, 2.0 }, { 3.0, 4.0 } }, vsub2, "vsub2" },
{ { -2.0, 2.0 }, { { 1.0, -2.0 }, { 3.0, -4.0 } }, vsub2, "vsub2" },
{ { 6.0, 4.0 }, { { 2.0, 8.0 }, { 3.0, 0.5 } }, vmul, "vmul" },
{ { 6.0, 4.0 }, { { 2.0, 8.0 }, { 3.0, 0.5 } }, vmul2, "vmul2" },
{ { 2.0, 0.5 }, { { 6.0, 4.0 }, { 3.0, 8.0 } }, vdiv, "vdiv" },
{ { 2.0, 0.5 }, { { 6.0, 4.0 }, { 3.0, 8.0 } }, vdiv2, "vdiv2" },
{ { 3.0, 4.0 }, { { 1.0, 2.0 }, { 3.0, 4.0 } }, vmax, "vmax" },
{ { 1.0, 4.0 }, { { 1.0, -2.0 }, { -3.0, 4.0 } }, vmax, "vmax" },
{ { 1.0, 2.0 }, { { 1.0, 2.0 }, { 3.0, 4.0 } }, vmin, "vmin" },
{ { -3.0, -2.0 }, { { 1.0, -2.0 }, { -3.0, 4.0 } }, vmin, "vmin" },
};
static void
test_arg2 (void)
{
unsigned i;
#ifdef DEBUG
printf ("\nTwo argument tests:\n");
#endif
for (i = 0; i < sizeof (arg2_tests) / sizeof (arg2_tests[0]); i++)
{
union args_d u;
u.vect = arg2_tests[i].func (arg2_tests[i].input[0].vect,
arg2_tests[i].input[1].vect);
#ifdef DEBUG
printf ("test %-16s: expected { %4g, %4g }, got { %4g, %4g }, input { %4g, %4g }, { %4g, %4g }\n",
arg2_tests[i].name,
arg2_tests[i].result.scalar[0],
arg2_tests[i].result.scalar[1],
u.scalar[0],
u.scalar[1],
arg2_tests[i].input[0].scalar[0],
arg2_tests[i].input[0].scalar[1],
arg2_tests[i].input[1].scalar[0],
arg2_tests[i].input[1].scalar[1]);
#endif
do_test_d (&arg2_tests[i].result, &u, arg2_tests[i].name);
}
return;
}
/* Comparisons, returnning a boolean vector. */
static vector bool long
vcmpeq (vector double arg1, vector double arg2)
{
return vec_cmpeq (arg1, arg2);
}
static vector bool long
vcmplt (vector double arg1, vector double arg2)
{
return vec_cmplt (arg1, arg2);
}
static vector bool long
vcmple (vector double arg1, vector double arg2)
{
return vec_cmple (arg1, arg2);
}
static vector bool long
vcmpgt (vector double arg1, vector double arg2)
{
return vec_cmpgt (arg1, arg2);
}
static vector bool long
vcmpge (vector double arg1, vector double arg2)
{
return vec_cmpge (arg1, arg2);
}
#define ONE 0xffffffffffffffffUL
#define ZERO 0x0000000000000000UL
/* comparison tests. */
static struct
{
union largs result;
union args_d input[2];
vector bool long (*func) (vector double, vector double);
const char *name;
} argcmp_tests[] = {
{ { ONE, ZERO }, { { 1.0, 2.0 }, { 1.0, -2.0 } }, vcmpeq, "vcmpeq" },
{ { ZERO, ONE }, { { -1.0, 2.0 }, { 1.0, 2.0 } }, vcmpeq, "vcmpeq" },
{ { ONE, ONE }, { { 1.0, -2.0 }, { 1.0, -2.0 } }, vcmple, "vcmple" },
{ { ONE, ONE }, { { 1.0, -2.0 }, { 2.0, -1.0 } }, vcmple, "vcmple" },
{ { ZERO, ZERO }, { { 2.0, -1.0 }, { 1.0, -2.0 } }, vcmple, "vcmple" },
{ { ZERO, ZERO }, { { 1.0, -2.0 }, { 1.0, -2.0 } }, vcmplt, "vcmplt" },
{ { ONE, ONE }, { { 1.0, -2.0 }, { 2.0, -1.0 } }, vcmplt, "vcmplt" },
{ { ZERO, ZERO }, { { 2.0, -1.0 }, { 1.0, -2.0 } }, vcmplt, "vcmplt" },
{ { ZERO, ZERO }, { { 1.0, -2.0 }, { 1.0, -2.0 } }, vcmpgt, "vcmpgt" },
{ { ZERO, ZERO }, { { 1.0, -2.0 }, { 2.0, -1.0 } }, vcmpgt, "vcmpgt" },
{ { ONE, ONE }, { { 2.0, -1.0 }, { 1.0, -2.0 } }, vcmpgt, "vcmpgt" },
{ { ONE, ONE }, { { 1.0, -2.0 }, { 1.0, -2.0 } }, vcmpge, "vcmpge" },
{ { ZERO, ZERO }, { { 1.0, -2.0 }, { 2.0, -1.0 } }, vcmpge, "vcmpge" },
{ { ONE, ONE }, { { 2.0, -1.0 }, { 1.0, -2.0 } }, vcmpge, "vcmpge" },
};
static void
test_argcmp (void)
{
unsigned i;
#ifdef DEBUG
printf ("\nComparison tests:\n");
#endif
for (i = 0; i < sizeof (argcmp_tests) / sizeof (argcmp_tests[0]); i++)
{
union largs u;
u.vect = argcmp_tests[i].func (argcmp_tests[i].input[0].vect,
argcmp_tests[i].input[1].vect);
#ifdef DEBUG
printf ("test %-16s: expected { 0x%016lx, 0x%016lx }, got { 0x%016lx, 0x%016lx }, input { %4g, %4g }, { %4g, %4g }\n",
argcmp_tests[i].name,
argcmp_tests[i].result.scalar[0],
argcmp_tests[i].result.scalar[1],
u.scalar[0],
u.scalar[1],
argcmp_tests[i].input[0].scalar[0],
argcmp_tests[i].input[0].scalar[1],
argcmp_tests[i].input[1].scalar[0],
argcmp_tests[i].input[1].scalar[1]);
#endif
do_ltest (&argcmp_tests[i].result, &u, argcmp_tests[i].name);
}
return;
}
int
main (int argc, char *argv[])
{
test_arg1_f ();
test_arg1_d ();
test_arg2 ();
test_argcmp ();
#ifdef DEBUG
if (errors)
{
printf ("There were %d error(s)\n", errors);
return errors;
}
else
printf ("There were no errors\n");
#endif
return 0;
}
|
