int main ()
{
vector unsigned char a = {2, 4, 6, 8, 10, 12, 14, 16,
18, 20, 22, 24, 26, 28, 30, 32};
vector unsigned char b = {3, 6, 9, 12, 15, 18, 21, 24,
27, 30, 33, 36, 39, 42, 45, 48};
vector unsigned char c = vmului (a, b);
vector unsigned char expect_c = {6, 24, 54, 96, 150, 216, 38, 128,
230, 88, 214, 96, 246, 152, 70, 0};
vector signed char d = {2, -4, 6, -8, 10, -12, 14, -16,
18, -20, 22, -24, 26, -28, 30, -32};
vector signed char e = {3, 6, -9, -12, 15, 18, -21, -24,
27, 30, -33, -36, 39, 42, -45, -48};
vector signed char f = vmulsi (d, e);
vector signed char expect_f = {6, -24, -54, 96, -106, 40, -38, -128,
-26, -88, 42, 96, -10, 104, -70, 0};
vector signed char g = {127, -128, 126, -126, 125, -125, 124, -124,
123, -123, 122, -122, 121, -121, 120, -120};
vector signed char h = { 2, 2, -2, -2, 127, 127, -128, -128,
10, 10, -10, -10, 64, 65, -64, -65};
vector signed char i = vmulsi (g, h);
vector signed char expect_i = {-2, 0, 4, -4, 3, -3, 0, 0,
-50, 50, 60, -60, 64, 71, 0, 120};
if (!vec_all_eq (c, expect_c))
abort ();
if (!vec_all_eq (f, expect_f))
abort ();
if (!vec_all_eq (i, expect_i))
abort ();
}
main ()
{
f2 ();
if (!vec_all_eq (var1, ref1))
abort ();
if (!vec_all_eq (var2, ref2))
abort ();
return 0;
}
int main ()
{
k = vec_add (a1, a2);
if (!vec_all_eq (addi, k))
abort ();
k = vec_avg (a1, a2);
if (!vec_all_eq (k, avgi))
abort ();
h = vec_add (f1, f2);
if (!vec_all_eq (h, addf))
abort ();
return 0;
}
static void test ()
{
vector unsigned long evul = {0,1};
vector double evd = {0.0,1.0};
vector unsigned long vul;
vector double vd;
init ();
vul = vec_ld (0, (vector unsigned long *)svul);
vd = vec_ld (0, (vector double *)svd);
check (vec_all_eq (vul, evul), "vul");
check (vec_all_eq (vd, evd ), "vd" );
}
static void test() {
vector unsigned char expected = {4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
check (vec_all_eq(vec_lvsl(0, &sc[4]), expected), "sc");
check (vec_all_eq(vec_lvsl(0, &uc[4]), expected), "uc");
check (vec_all_eq(vec_lvsl(0, &ss[2]), expected), "ss");
check (vec_all_eq(vec_lvsl(0, &us[2]), expected), "us");
check (vec_all_eq(vec_lvsl(0, &si[1]), expected), "si");
check (vec_all_eq(vec_lvsl(0, &ui[1]), expected), "ui");
check (vec_all_eq(vec_lvsl(0, & f[1]), expected), "f");
}
/*! <em>Pointwise Equality</em> of vA and vB. */
inline int vec4i_all_eq(vec4i vA, vec4i vB) {
#if defined(__ALTIVEC__) /* AltiVec */
return vec_all_eq((vector int)vA, (vector int)vB);
#else /* Scalar */
int * s1 = (int*)&vA;
int * s2 = (int*)&vB;
return (s1[0] == s2[0] and
s1[1] == s2[1] and
s1[2] == s2[2] and
s1[3] == s2[3]);
#endif
}
void
check_cmple()
{
vector float a = {1.0, 2.0, 3.0, 4.0};
vector float b = {1.0, 3.0, 2.0, 5.0};
vector bool int aux;
vector signed int le = {-1, -1, 0, -1};
aux = vec_cmple (a, b);
if (!vec_all_eq (aux, le))
abort ();
}
int *v4si_u (vector unsigned int *a, vector unsigned int *b, int *p)
{
if (vec_all_eq (*a, *b))
*p++ = 1;
if (vec_all_gt (*a, *b))
*p++ = 2;
if (vec_all_ge (*a, *b))
*p++ = 2;
return p;
}
int *v16qi_u (vector unsigned char *a, vector unsigned char *b, int *p)
{
if (vec_all_eq (*a, *b))
*p++ = 1;
if (vec_all_gt (*a, *b))
*p++ = 2;
if (vec_all_ge (*a, *b))
*p++ = 2;
return p;
}
int *v4si_s (vector int *a, vector int *b, int *p)
{
if (vec_all_eq (*a, *b))
*p++ = 1;
if (vec_all_gt (*a, *b))
*p++ = 2;
if (vec_all_ge (*a, *b))
*p++ = 2;
return p;
}
int *v2df (vector double *a, vector double *b, int *p)
{
if (vec_all_eq (*a, *b))
*p++ = 1;
if (vec_all_gt (*a, *b))
*p++ = 2;
if (vec_all_ge (*a, *b))
*p++ = 3;
return p;
}
int triangleEvaluateHalfSpace(const Triangle3DSetup &tri, VecRef xShuffle, VecRef yShuffle)
{
Vec DX12 = vec(tri.dx1);
Vec DX23 = vec(tri.dx2);
Vec DX31 = vec(tri.dx3);
Vec DY12 = vec(tri.dy1);
Vec DY23 = vec(tri.dy2);
Vec DY31 = vec(tri.dy3);
TriangleSetup s;
triangleCalculateConstants(tri, s);
Vec C1 = vec(s.c1);
Vec C2 = vec(s.c2);
Vec C3 = vec(s.c3);
const Vec Zero = vec(0);
const Vec p = vecCmpGT(vecSub(vecMadd(DX12, yShuffle, C1), vecMul(DY12, xShuffle)), Zero);
const Vec q = vecCmpGT(vecSub(vecMadd(DX23, yShuffle, C2), vecMul(DY23, xShuffle)), Zero);
const Vec r = vecCmpGT(vecSub(vecMadd(DX31, yShuffle, C3), vecMul(DY31, xShuffle)), Zero);
#ifndef PLATFORM_PS3
const int a = vecMaskToInt(p);
const int b = vecMaskToInt(q);
const int c = vecMaskToInt(r);
if(!a || !b || !c)
{
return FullyOutside;
}
else if(a == 0xf && b == 0xf && c == 0xf)
{
return FullyCovered;
}
else
{
return PartiallyInside;
}
#else
vec_uint4 ones = (vec_uint4){0xffffffff,0xffffffff,0xffffffff,0xffffffff};
vec_uint4 zeros = (vec_uint4){0, 0, 0, 0};
if(vec_all_eq((vec_uint4)p, zeros) || vec_all_eq((vec_uint4)q, zeros) || vec_all_eq((vec_uint4)r, zeros))
{
return FullyOutside;
}
else if(vec_all_eq((vec_uint4)p, ones) && vec_all_eq((vec_uint4)q, ones) && vec_all_eq((vec_uint4)r, ones))
{
return FullyCovered;
}
else
{
return PartiallyInside;
}
#endif
}
int *v4sf (vector float *a, vector float *b, int *p)
{
if (vec_all_eq (*a, *b))
*p++ = 1;
if (vec_all_gt (*a, *b))
*p++ = 2;
if (vec_all_ge (*a, *b))
*p++ = 3;
if (vec_all_in (*a, *b)) /* veccmpbfp. */
*p++ = 4;
return p;
}
static void test()
{
/* Input vectors. */
vector long long vla = {-2,-1};
vector long long vlb = {0,1};
vector double vda = {-2.0,-1.0};
vector double vdb = {0.0,1.0};
vector unsigned int vuia = {0,1,2,3};
vector unsigned int vuib = {4,5,6,7};
vector signed int vsia = {-4,-3,-2,-1};
vector signed int vsib = {0,1,2,3};
vector float vfa = {-4.0,-3.0,-2.0,-1.0};
vector float vfb = {0.0,1.0,2.0,3.0};
/* Result vectors. */
vector long long vlh, vll;
vector double vdh, vdl;
vector unsigned int vuih, vuil;
vector signed int vsih, vsil;
vector float vfh, vfl;
/* Expected result vectors. */
vector long long vlrh = {-2,0};
vector long long vlrl = {-1,1};
vector double vdrh = {-2.0,0.0};
vector double vdrl = {-1.0,1.0};
vector unsigned int vuirh = {0,4,1,5};
vector unsigned int vuirl = {2,6,3,7};
vector signed int vsirh = {-4,0,-3,1};
vector signed int vsirl = {-2,2,-1,3};
vector float vfrh = {-4.0,0.0,-3.0,1.0};
vector float vfrl = {-2.0,2.0,-1.0,3.0};
vlh = vec_mergeh (vla, vlb);
vll = vec_mergel (vla, vlb);
vdh = vec_mergeh (vda, vdb);
vdl = vec_mergel (vda, vdb);
vuih = vec_mergeh (vuia, vuib);
vuil = vec_mergel (vuia, vuib);
vsih = vec_mergeh (vsia, vsib);
vsil = vec_mergel (vsia, vsib);
vfh = vec_mergeh (vfa, vfb );
vfl = vec_mergel (vfa, vfb );
check (vec_long_long_eq (vlh, vlrh), "vlh");
check (vec_long_long_eq (vll, vlrl), "vll");
check (vec_double_eq (vdh, vdrh), "vdh" );
check (vec_double_eq (vdl, vdrl), "vdl" );
check (vec_all_eq (vuih, vuirh), "vuih");
check (vec_all_eq (vuil, vuirl), "vuil");
check (vec_all_eq (vsih, vsirh), "vsih");
check (vec_all_eq (vsil, vsirl), "vsil");
check (vec_all_eq (vfh, vfrh), "vfh");
check (vec_all_eq (vfl, vfrl), "vfl");
}
void
b()
{
z = vec_add (x, y);
/* Make sure the predicates accept correct argument types. */
int1 = vec_all_in (f, g);
int1 = vec_all_ge (f, g);
int1 = vec_all_eq (c, d);
int1 = vec_all_ne (s, t);
int1 = vec_any_eq (i, j);
int1 = vec_any_ge (f, g);
int1 = vec_all_ngt (f, g);
int1 = vec_any_ge (c, d);
int1 = vec_any_ge (s, t);
int1 = vec_any_ge (i, j);
int1 = vec_any_ge (c, d);
int1 = vec_any_ge (s, t);
int1 = vec_any_ge (i, j);
vec_mtvscr (i);
vec_dssall ();
s = (vector signed short) vec_mfvscr ();
vec_dss (3);
vec_dst (pi, int1 + int2, 3);
vec_dstst (pi, int1 + int2, 3);
vec_dststt (pi, int1 + int2, 3);
vec_dstt (pi, int1 + int2, 3);
uc = (vector unsigned char) vec_lvsl (int1 + 69, (signed int *) pi);
uc = (vector unsigned char) vec_lvsr (int1 + 69, (signed int *) pi);
c = vec_lde (int1, (signed char *) pi);
s = vec_lde (int1, (signed short *) pi);
i = vec_lde (int1, (signed int *) pi);
i = vec_ldl (int1, pi);
i = vec_ld (int1, pi);
vec_st (i, int2, pi);
vec_ste (c, int2, (signed char *) pi);
vec_ste (s, int2, (signed short *) pi);
vec_ste (i, int2, (signed int *) pi);
vec_stl (i, int2, pi);
}
int main ()
{
vector float fa = {1.0, 2.0, 3.0, -4.0};
vector float fb = {-2.0, -3.0, -4.0, -5.0};
vector float fc = vec_cpsgn (fa, fb);
vector long long la = {5L, 14L};
vector long long lb = {3L, 86L};
vector long long lc = vec_and (la, lb);
vector bool long long ld = {0, -1};
vector long long le = vec_and (la, ld);
vector long long lf = vec_and (ld, lb);
vector unsigned long long ua = {5L, 14L};
vector unsigned long long ub = {3L, 86L};
vector unsigned long long uc = vec_and (ua, ub);
vector bool long long ud = {0, -1};
vector unsigned long long ue = vec_and (ua, ud);
vector unsigned long long uf = vec_and (ud, ub);
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 long long lj = vec_mergeh (la, lb);
vector long long lk = vec_mergeh (la, ld);
vector long long ll = vec_mergeh (ld, la);
vector unsigned long long uj = vec_mergeh (ua, ub);
vector unsigned long long uk = vec_mergeh (ua, ud);
vector unsigned long long ul = vec_mergeh (ud, ua);
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 um = vec_mergel (ua, ub);
vector unsigned long long un = vec_mergel (ua, ud);
vector unsigned long long uo = vec_mergel (ud, ua);
vector long long lp = vec_nor (la, lb);
vector long long lq = vec_nor (la, ld);
vector long long lr = vec_nor (ld, la);
vector unsigned long long up = vec_nor (ua, ub);
vector unsigned long long uq = vec_nor (ua, ud);
vector unsigned long long ur = vec_nor (ud, ua);
vector long long ls = vec_or (la, lb);
vector long long lt = vec_or (la, ld);
vector long long lu = vec_or (ld, la);
vector unsigned long long us = vec_or (ua, ub);
vector unsigned long long ut = vec_or (ua, ud);
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 long long lv = vec_perm (la, lb, ca);
vector unsigned long long uv = vec_perm (ua, ub, ca);
vector long long lw = vec_sel (la, lb, lc);
vector long long lx = vec_sel (la, lb, uc);
vector long long ly = vec_sel (la, lb, ld);
vector unsigned long long uw = vec_sel (ua, ub, lc);
vector unsigned long long ux = vec_sel (ua, ub, uc);
vector unsigned long long uy = vec_sel (ua, ub, ld);
vector long long lz = vec_xor (la, lb);
vector long long l0 = vec_xor (la, ld);
vector long long l1 = vec_xor (ld, la);
vector unsigned long long uz = vec_xor (ua, ub);
vector unsigned long long u0 = vec_xor (ua, ud);
vector unsigned long long u1 = vec_xor (ud, ua);
int ia = vec_all_eq (ua, ub);
int ib = vec_all_ge (ua, ub);
int ic = vec_all_gt (ua, ub);
int id = vec_all_le (ua, ub);
int ie = vec_all_lt (ua, ub);
int ig = vec_all_ne (ua, ub);
int ih = vec_any_eq (ua, ub);
int ii = vec_any_ge (ua, ub);
int ij = vec_any_gt (ua, ub);
int ik = vec_any_le (ua, ub);
int il = vec_any_lt (ua, ub);
int im = vec_any_ne (ua, ub);
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 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 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 unsigned int uie = vec_packsu (ua, ub);
vector long long l2 = vec_cntlz (la);
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 unsigned short usa = {81, 72, 63, 54, 45, 36, 27, 18};
vector unsigned short usb = vec_cntlz (usa);
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 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 df = vec_splat (de, 0);
vector double dg = 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 unsigned long long u4 = vec_splat (u2, 1);
vector bool long long l5 = vec_splat (ld, 0);
vector bool long long l6 = vec_splat (ld, 1);
vector long long l7 = vec_div (l3, l4);
vector unsigned long long u5 = vec_div (u3, u4);
vector long long l8 = vec_mul (l3, l4);
vector unsigned long long u6 = vec_mul (u3, u4);
vector double dh = vec_ctf (la, -2);
vector double di = vec_ctf (ua, 2);
vector long long l9 = vec_cts (dh, -2);
vector unsigned long long u7 = vec_ctu (di, 2);
return 0;
}
static void test()
{
static vector bool char zero;
check(vec_all_eq(f(), zero), "f");
}
static void test()
{
/* Input vectors. */
vector unsigned short vusa = {0,1,2,3,4,5,6,7};
vector unsigned short vusb = {8,9,10,11,12,13,14,15};
vector signed short vssa = {-8,-7,-6,-5,-4,-3,-2,-1};
vector signed short vssb = {0,1,2,3,4,5,6,7};
vector bool short vbsa = {0,65535,65535,0,0,0,65535,0};
vector bool short vbsb = {65535,0,0,65535,65535,65535,0,65535};
vector unsigned int vuia = {0,1,2,3};
vector unsigned int vuib = {4,5,6,7};
vector signed int vsia = {-4,-3,-2,-1};
vector signed int vsib = {0,1,2,3};
vector bool int vbia = {0,BIG,BIG,BIG};
vector bool int vbib = {BIG,0,0,0};
vector unsigned int vipa = {(0<<24) + (2<<19) + (3<<11) + (4<<3),
(1<<24) + (5<<19) + (6<<11) + (7<<3),
(0<<24) + (8<<19) + (9<<11) + (10<<3),
(1<<24) + (11<<19) + (12<<11) + (13<<3)};
vector unsigned int vipb = {(1<<24) + (14<<19) + (15<<11) + (16<<3),
(0<<24) + (17<<19) + (18<<11) + (19<<3),
(1<<24) + (20<<19) + (21<<11) + (22<<3),
(0<<24) + (23<<19) + (24<<11) + (25<<3)};
vector unsigned short vusc = {0,256,1,257,2,258,3,259};
vector unsigned short vusd = {4,260,5,261,6,262,7,263};
vector signed short vssc = {-1,-128,0,127,-2,-129,1,128};
vector signed short vssd = {-3,-130,2,129,-4,-131,3,130};
vector unsigned int vuic = {0,65536,1,65537};
vector unsigned int vuid = {2,65538,3,65539};
vector signed int vsic = {-1,-32768,0,32767};
vector signed int vsid = {-2,-32769,1,32768};
/* Result vectors. */
vector unsigned char vucr;
vector signed char vscr;
vector bool char vbcr;
vector unsigned short vusr;
vector signed short vssr;
vector bool short vbsr;
vector pixel vpr;
vector unsigned char vucsr;
vector signed char vscsr;
vector unsigned short vussr;
vector signed short vsssr;
vector unsigned char vucsur1, vucsur2;
vector unsigned short vussur1, vussur2;
/* Expected result vectors. */
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
vector unsigned char vucer = {8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7};
vector signed char vscer = {0,1,2,3,4,5,6,7,-8,-7,-6,-5,-4,-3,-2,-1};
vector bool char vbcer = {255,0,0,255,255,255,0,255,0,255,255,0,0,0,255,0};
vector unsigned short vuser = {4,5,6,7,0,1,2,3};
vector signed short vsser = {0,1,2,3,-4,-3,-2,-1};
vector bool short vbser = {65535,0,0,0,0,65535,65535,65535};
vector pixel vper = {(1<<15) + (14<<10) + (15<<5) + 16,
(0<<15) + (17<<10) + (18<<5) + 19,
(1<<15) + (20<<10) + (21<<5) + 22,
(0<<15) + (23<<10) + (24<<5) + 25,
(0<<15) + (2<<10) + (3<<5) + 4,
(1<<15) + (5<<10) + (6<<5) + 7,
(0<<15) + (8<<10) + (9<<5) + 10,
(1<<15) + (11<<10) + (12<<5) + 13};
vector unsigned char vucser = {4,255,5,255,6,255,7,255,0,255,1,255,2,255,3,255};
vector signed char vscser = {-3,-128,2,127,-4,-128,3,127,
-1,-128,0,127,-2,-128,1,127};
vector unsigned short vusser = {2,65535,3,65535,0,65535,1,65535};
vector signed short vssser = {-2,-32768,1,32767,-1,-32768,0,32767};
vector unsigned char vucsuer1 = {4,255,5,255,6,255,7,255,0,255,1,255,2,255,3,255};
vector unsigned char vucsuer2 = {0,0,2,129,0,0,3,130,0,0,0,127,0,0,1,128};
vector unsigned short vussuer1 = {2,65535,3,65535,0,65535,1,65535};
vector unsigned short vussuer2 = {0,0,1,32768,0,0,0,32767};
#else
vector unsigned char vucer = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
vector signed char vscer = {-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7};
vector bool char vbcer = {0,255,255,0,0,0,255,0,255,0,0,255,255,255,0,255};
vector unsigned short vuser = {0,1,2,3,4,5,6,7};
vector signed short vsser = {-4,-3,-2,-1,0,1,2,3};
vector bool short vbser = {0,65535,65535,65535,65535,0,0,0};
vector pixel vper = {(0<<15) + (2<<10) + (3<<5) + 4,
(1<<15) + (5<<10) + (6<<5) + 7,
(0<<15) + (8<<10) + (9<<5) + 10,
(1<<15) + (11<<10) + (12<<5) + 13,
(1<<15) + (14<<10) + (15<<5) + 16,
(0<<15) + (17<<10) + (18<<5) + 19,
(1<<15) + (20<<10) + (21<<5) + 22,
(0<<15) + (23<<10) + (24<<5) + 25};
vector unsigned char vucser = {0,255,1,255,2,255,3,255,4,255,5,255,6,255,7,255};
vector signed char vscser = {-1,-128,0,127,-2,-128,1,127,
-3,-128,2,127,-4,-128,3,127};
vector unsigned short vusser = {0,65535,1,65535,2,65535,3,65535};
vector signed short vssser = {-1,-32768,0,32767,-2,-32768,1,32767};
vector unsigned char vucsuer1 = {0,255,1,255,2,255,3,255,4,255,5,255,6,255,7,255};
vector unsigned char vucsuer2 = {0,0,0,127,0,0,1,128,0,0,2,129,0,0,3,130};
vector unsigned short vussuer1 = {0,65535,1,65535,2,65535,3,65535};
vector unsigned short vussuer2 = {0,0,0,32767,0,0,1,32768};
#endif
vucr = vec_pack (vusa, vusb);
vscr = vec_pack (vssa, vssb);
vbcr = vec_pack (vbsa, vbsb);
vusr = vec_pack (vuia, vuib);
vssr = vec_pack (vsia, vsib);
vbsr = vec_pack (vbia, vbib);
vpr = vec_packpx (vipa, vipb);
vucsr = vec_packs (vusc, vusd);
vscsr = vec_packs (vssc, vssd);
vussr = vec_packs (vuic, vuid);
vsssr = vec_packs (vsic, vsid);
vucsur1 = vec_packsu (vusc, vusd);
vucsur2 = vec_packsu (vssc, vssd);
vussur1 = vec_packsu (vuic, vuid);
vussur2 = vec_packsu (vsic, vsid);
check (vec_all_eq (vucr, vucer), "vucr");
check (vec_all_eq (vscr, vscer), "vscr");
check (vec_all_eq (vbcr, vbcer), "vbcr");
check (vec_all_eq (vusr, vuser), "vusr");
check (vec_all_eq (vssr, vsser), "vssr");
check (vec_all_eq (vbsr, vbser), "vbsr");
check (vec_all_eq (vpr, vper ), "vpr" );
check (vec_all_eq (vucsr, vucser), "vucsr");
check (vec_all_eq (vscsr, vscser), "vscsr");
check (vec_all_eq (vussr, vusser), "vussr");
check (vec_all_eq (vsssr, vssser), "vsssr");
check (vec_all_eq (vucsur1, vucsuer1), "vucsur1");
check (vec_all_eq (vucsur2, vucsuer2), "vucsur2");
check (vec_all_eq (vussur1, vussuer1), "vussur1");
check (vec_all_eq (vussur2, vussuer2), "vussur2");
}
void triangleVertexShading(JmJob *data)
{
VertexJob v;
dmaBlockGet(&v, (uintptr_t)data->p1, sizeof(VertexJob), DmaTag);
Vec halfSizeAdd = vec(0.5f * sw, 0.5f * sh, 0, 1);
Vec halfSizeMul = vec(0.5f * sw, -0.5f * sh, 1, 0);
Vec zero = vec(0);
Mat transform;
matMul(&transform, v.projection, v.world);
while(true)
{
unsigned int k = interlockedExchangeAdd(v.counter, VerticesAtATime);
if(k >= v.end) break;
unsigned int end = std::min(k + VerticesAtATime, v.end);
unsigned int num = end - k;
unsigned int numtris = num / 3;
#ifndef PLATFORM_PS3_SPU
Triangle3D vertexShadingTris[TriangleAtATime];
#endif
dmaBlockGet(vertexShadingTris, (uintptr_t)&v.input[k], numtris * sizeof(Triangle3D), DmaTag);
for(unsigned int u = 0; u < numtris; u++)
{
const Triangle3D &tri = vertexShadingTris[u];
Triangle3D triOut[5];
Vec vtx[8];
int numTrisOut = 1;
if(g_EnableBackfaceCulling)
{
// We can't do the backface culling using a determinant of a 2x2 matrix
// in screen space because then we would have 'holes' in the output data
// therefor it happens here, in wordspace.
Vec e1 = vecSub(tri.p3, tri.p1);
Vec e2 = vecSub(tri.p2, tri.p1);
Vec n = vecCross(e1, e2);
Vec a = vecDot(v.camerapos, n);
if(vecGetElem(a, VecComponent::X) > 0) continue;
}
// perspective project
matMulVec(&triOut[0].p1, transform, tri.p1);
matMulVec(&triOut[0].p2, transform, tri.p2);
matMulVec(&triOut[0].p3, transform, tri.p3);
// cull against znear
Vec m1 = vecCmpLE(vecSplat<VecComponent::Z>(triOut[0].p1), zero);
Vec m2 = vecCmpLE(vecSplat<VecComponent::Z>(triOut[0].p2), zero);
Vec m3 = vecCmpLE(vecSplat<VecComponent::Z>(triOut[0].p3), zero);
Vec c2 = vecAnd(vecAnd(m1, m2), m3);
#ifdef PLATFORM_PS3
vec_uint4 ones = (vec_uint4){0xffffffff,0xffffffff,0xffffffff,0xffffffff};
if(vec_all_eq((vec_uint4)c2, ones)) continue;
#else
int result = vecMaskToInt(c2);
if(result == 15) continue; // discard, all behind nearz
#endif
#if 1
// clip triangles that intersect znear
static const int NumVerticesInATriangle = 3;
int numVertsOut = triangleClipToPlane(
(Vec*)&triOut[0],
vtx,
NumVerticesInATriangle,
vec(0, 0, 1, 0)
);
// Very simple triangulation routine
numTrisOut = 0;
for(int i = 2; i < numVertsOut; i++)
{
triOut[numTrisOut].p1 = vtx[0];
triOut[numTrisOut].p2 = vtx[i];
triOut[numTrisOut].p3 = vtx[i - 1];
numTrisOut++;
}
#endif
for(int i = 0; i < numTrisOut; i++)
{
// perspective divide
triOut[i].p1 = vecMul(triOut[i].p1, vecRcp(vecSplat<VecComponent::W>(triOut[i].p1)));
triOut[i].p2 = vecMul(triOut[i].p2, vecRcp(vecSplat<VecComponent::W>(triOut[i].p2)));
triOut[i].p3 = vecMul(triOut[i].p3, vecRcp(vecSplat<VecComponent::W>(triOut[i].p3)));
// transform to screen space
Vec r1 = vecMadd(triOut[i].p1, halfSizeMul, halfSizeAdd);
Vec r2 = vecMadd(triOut[i].p2, halfSizeMul, halfSizeAdd);
Vec r3 = vecMadd(triOut[i].p3, halfSizeMul, halfSizeAdd);
#ifdef PLATFORM_PS3_SPU
Triangle3DSetup &r = setup[s][sidx];
#else
Triangle3DSetup r;
#endif
memcpy(&r.x1, &r1, sizeof(float) * 3);
memcpy(&r.x2, &r2, sizeof(float) * 3);
memcpy(&r.x3, &r3, sizeof(float) * 3);
// deltas
r.dx1 = r.x1 - r.x2;
r.dx2 = r.x2 - r.x3;
r.dx3 = r.x3 - r.x1;
r.dy1 = r.y1 - r.y2;
r.dy2 = r.y2 - r.y3;
r.dy3 = r.y3 - r.y1;
#ifdef PLATFORM_PS3_SPU
sidx++;
if(sidx >= MaxSetupBuffered)
{
dmaWaitAll(1 << DmaListTag);
unsigned int l = interlockedExchangeAdd(v.outputCnt, sidx);
for(unsigned int u = 0; u < sidx; u++)
{
setuplist[u].notify = 0;
setuplist[u].reserved = 0;
setuplist[u].size = sizeof(Triangle3DSetup);
setuplist[u].eal = (uintptr_t)&v.output[u + l];
}
cellDmaListPut(setup[s], 0, setuplist, sizeof(setuplist), DmaListTag, 0, 0);
sidx = 0;
s ^= 1;
}
#else
unsigned int l = interlockedExchangeAdd(v.outputCnt, 1);
if(l >= MaxTrianglesDrawn) { interlockedExchangeSub(v.outputCnt, 1); break; }
else dmaBlockPut(&r, (uintptr_t)&v.output[l], sizeof(Triangle3DSetup), DmaTag);
#endif
}
}
}
#ifdef PLATFORM_PS3_SPU
if(sidx > 0)
{
dmaWaitAll(1 << DmaListTag);
unsigned int l = interlockedExchangeAdd(v.outputCnt, sidx);
for(unsigned int u = 0; u < sidx; u++)
{
setuplist[u].notify = 0;
setuplist[u].reserved = 0;
setuplist[u].size = sizeof(Triangle3DSetup);
setuplist[u].eal = (uintptr_t)&v.output[u + l];
}
cellDmaListPut(setup[s], 0, setuplist, sidx * sizeof(CellDmaListElement), DmaListTag + 1, 0, 0);
dmaWaitAll(1 << (DmaListTag + 1));
}
#endif
}
int main()
{
if (!vec_all_eq(u8a, u8b))
abort ();
return 0;
}
static int
forward_engine(int do_full, const ESL_DSQ *dsq, int L, const P7_OPROFILE *om, P7_OMX *ox, float *opt_sc)
{
vector float mpv, dpv, ipv; /* previous row values */
vector float sv; /* temp storage of 1 curr row value in progress */
vector float dcv; /* delayed storage of D(i,q+1) */
vector float xEv; /* E state: keeps max for Mk->E as we go */
vector float xBv; /* B state: splatted vector of B[i-1] for B->Mk calculations */
vector float zerov; /* splatted 0.0's in a vector */
float xN, xE, xB, xC, xJ; /* special states' scores */
int i; /* counter over sequence positions 1..L */
int q; /* counter over quads 0..nq-1 */
int j; /* counter over DD iterations (4 is full serialization) */
int Q = p7O_NQF(om->M); /* segment length: # of vectors */
vector float *dpc = ox->dpf[0]; /* current row, for use in {MDI}MO(dpp,q) access macro */
vector float *dpp; /* previous row, for use in {MDI}MO(dpp,q) access macro */
vector float *rp; /* will point at om->rfv[x] for residue x[i] */
vector float *tp; /* will point into (and step thru) om->tfv */
/* Initialization. */
ox->M = om->M;
ox->L = L;
ox->has_own_scales = TRUE; /* all forward matrices control their own scalefactors */
zerov = (vector float) vec_splat_u32(0);
for (q = 0; q < Q; q++)
MMO(dpc,q) = IMO(dpc,q) = DMO(dpc,q) = zerov;
xE = ox->xmx[p7X_E] = 0.;
xN = ox->xmx[p7X_N] = 1.;
xJ = ox->xmx[p7X_J] = 0.;
xB = ox->xmx[p7X_B] = om->xf[p7O_N][p7O_MOVE];
xC = ox->xmx[p7X_C] = 0.;
ox->xmx[p7X_SCALE] = 1.0;
ox->totscale = 0.0;
#if p7_DEBUGGING
if (ox->debugging) p7_omx_DumpFBRow(ox, TRUE, 0, 9, 5, xE, xN, xJ, xB, xC); /* logify=TRUE, <rowi>=0, width=8, precision=5*/
#endif
for (i = 1; i <= L; i++)
{
dpp = dpc;
dpc = ox->dpf[do_full * i]; /* avoid conditional, use do_full as kronecker delta */
rp = om->rfv[dsq[i]];
tp = om->tfv;
dcv = (vector float) vec_splat_u32(0);
xEv = (vector float) vec_splat_u32(0);
xBv = esl_vmx_set_float(xB);
/* Right shifts by 4 bytes. 4,8,12,x becomes x,4,8,12. Shift zeros on. */
mpv = vec_sld(zerov, MMO(dpp,Q-1), 12);
dpv = vec_sld(zerov, DMO(dpp,Q-1), 12);
ipv = vec_sld(zerov, IMO(dpp,Q-1), 12);
for (q = 0; q < Q; q++)
{
/* Calculate new MMO(i,q); don't store it yet, hold it in sv. */
sv = (vector float) vec_splat_u32(0);
sv = vec_madd(xBv, *tp, sv); tp++;
sv = vec_madd(mpv, *tp, sv); tp++;
sv = vec_madd(ipv, *tp, sv); tp++;
sv = vec_madd(dpv, *tp, sv); tp++;
sv = vec_madd(sv, *rp, zerov); rp++;
xEv = vec_add(xEv, sv);
/* Load {MDI}(i-1,q) into mpv, dpv, ipv;
* {MDI}MX(q) is then the current, not the prev row
*/
mpv = MMO(dpp,q);
dpv = DMO(dpp,q);
ipv = IMO(dpp,q);
/* Do the delayed stores of {MD}(i,q) now that memory is usable */
MMO(dpc,q) = sv;
DMO(dpc,q) = dcv;
/* Calculate the next D(i,q+1) partially: M->D only;
* delay storage, holding it in dcv
*/
dcv = vec_madd(sv, *tp, zerov); tp++;
/* Calculate and store I(i,q); assumes odds ratio for emission is 1.0 */
sv = vec_madd(mpv, *tp, zerov); tp++;
IMO(dpc,q) = vec_madd(ipv, *tp, sv); tp++;
}
/* Now the DD paths. We would rather not serialize them but
* in an accurate Forward calculation, we have few options.
*/
/* dcv has carried through from end of q loop above; store it
* in first pass, we add M->D and D->D path into DMX
*/
/* We're almost certainly're obligated to do at least one complete
* DD path to be sure:
*/
dcv = vec_sld(zerov, dcv, 12);
DMO(dpc,0) = (vector float) vec_splat_u32(0);
tp = om->tfv + 7*Q; /* set tp to start of the DD's */
for (q = 0; q < Q; q++)
{
DMO(dpc,q) = vec_add(dcv, DMO(dpc,q));
dcv = vec_madd(DMO(dpc,q), *tp, zerov); tp++; /* extend DMO(q), so we include M->D and D->D paths */
}
/* now. on small models, it seems best (empirically) to just go
* ahead and serialize. on large models, we can do a bit better,
* by testing for when dcv (DD path) accrued to DMO(q) is below
* machine epsilon for all q, in which case we know DMO(q) are all
* at their final values. The tradeoff point is (empirically) somewhere around M=100,
* at least on my desktop. We don't worry about the conditional here;
* it's outside any inner loops.
*/
if (om->M < 100)
{ /* Fully serialized version */
for (j = 1; j < 4; j++)
{
dcv = vec_sld(zerov, dcv, 12);
tp = om->tfv + 7*Q; /* set tp to start of the DD's */
for (q = 0; q < Q; q++)
{ /* note, extend dcv, not DMO(q); only adding DD paths now */
DMO(dpc,q) = vec_add(dcv, DMO(dpc,q));
dcv = vec_madd(dcv, *tp, zerov); tp++;
}
}
}
else
{ /* Slightly parallelized version, but which incurs some overhead */
for (j = 1; j < 4; j++)
{
vector bool int cv; /* keeps track of whether any DD's change DMO(q) */
dcv = vec_sld(zerov, dcv, 12);
tp = om->tfv + 7*Q; /* set tp to start of the DD's */
cv = (vector bool int) vec_splat_u32(0);
for (q = 0; q < Q; q++)
{ /* using cmpgt below tests if DD changed any DMO(q) *without* conditional branch */
sv = vec_add(dcv, DMO(dpc,q));
cv = vec_or(cv, vec_cmpgt(sv, DMO(dpc,q)));
DMO(dpc,q) = sv; /* store new DMO(q) */
dcv = vec_madd(dcv, *tp, zerov); tp++; /* note, extend dcv, not DMO(q) */
}
/* DD's didn't change any DMO(q)? Then done, break out. */
if (vec_all_eq(cv, (vector bool int)zerov)) break;
}
}
/* Add D's to xEv */
for (q = 0; q < Q; q++) xEv = vec_add(DMO(dpc,q), xEv);
/* Finally the "special" states, which start from Mk->E (->C, ->J->B) */
/* The following incantation is a horizontal sum of xEv's elements */
/* These must follow DD calculations, because D's contribute to E in Forward
* (as opposed to Viterbi)
*/
xE = esl_vmx_hsum_float(xEv);
xN = xN * om->xf[p7O_N][p7O_LOOP];
xC = (xC * om->xf[p7O_C][p7O_LOOP]) + (xE * om->xf[p7O_E][p7O_MOVE]);
xJ = (xJ * om->xf[p7O_J][p7O_LOOP]) + (xE * om->xf[p7O_E][p7O_LOOP]);
xB = (xJ * om->xf[p7O_J][p7O_MOVE]) + (xN * om->xf[p7O_N][p7O_MOVE]);
/* and now xB will carry over into next i, and xC carries over after i=L */
/* Sparse rescaling. xE above threshold? trigger a rescaling event. */
if (xE > 1.0e4) /* that's a little less than e^10, ~10% of our dynamic range */
{
xN = xN / xE;
xC = xC / xE;
xJ = xJ / xE;
xB = xB / xE;
xEv = esl_vmx_set_float(1.0 / xE);
for (q = 0; q < Q; q++)
{
MMO(dpc,q) = vec_madd(MMO(dpc,q), xEv, zerov);
DMO(dpc,q) = vec_madd(DMO(dpc,q), xEv, zerov);
IMO(dpc,q) = vec_madd(IMO(dpc,q), xEv, zerov);
}
ox->xmx[i*p7X_NXCELLS+p7X_SCALE] = xE;
ox->totscale += log(xE);
xE = 1.0;
}
else ox->xmx[i*p7X_NXCELLS+p7X_SCALE] = 1.0;
/* Storage of the specials. We could've stored these already
* but using xE, etc. variables makes it easy to convert this
* code to O(M) memory versions just by deleting storage steps.
*/
ox->xmx[i*p7X_NXCELLS+p7X_E] = xE;
ox->xmx[i*p7X_NXCELLS+p7X_N] = xN;
ox->xmx[i*p7X_NXCELLS+p7X_J] = xJ;
ox->xmx[i*p7X_NXCELLS+p7X_B] = xB;
ox->xmx[i*p7X_NXCELLS+p7X_C] = xC;
#if p7_DEBUGGING
if (ox->debugging) p7_omx_DumpFBRow(ox, TRUE, i, 9, 5, xE, xN, xJ, xB, xC); /* logify=TRUE, <rowi>=i, width=8, precision=5*/
#endif
} /* end loop over sequence residues 1..L */
/* finally C->T, and flip total score back to log space (nats) */
/* On overflow, xC is inf or nan (nan arises because inf*0 = nan). */
/* On an underflow (which shouldn't happen), we counterintuitively return infinity:
* the effect of this is to force the caller to rescore us with full range.
*/
if (isnan(xC)) ESL_EXCEPTION(eslERANGE, "forward score is NaN");
else if (L>0 && xC == 0.0) ESL_EXCEPTION(eslERANGE, "forward score underflow (is 0.0)"); /* [J5/118] */
else if (isinf(xC) == 1) ESL_EXCEPTION(eslERANGE, "forward score overflow (is infinity)");
if (opt_sc != NULL) *opt_sc = ox->totscale + log(xC * om->xf[p7O_C][p7O_MOVE]);
return eslOK;
}
static void test()
{
/* Input vectors. */
vector signed char vsc = {-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7};
vector bool char vbc = {0,255,255,0,0,0,255,0,255,0,0,255,255,255,0,255};
vector pixel vp = {(0<<15) + (1<<10) + (2<<5) + 3,
(1<<15) + (4<<10) + (5<<5) + 6,
(0<<15) + (7<<10) + (8<<5) + 9,
(1<<15) + (10<<10) + (11<<5) + 12,
(1<<15) + (13<<10) + (14<<5) + 15,
(0<<15) + (16<<10) + (17<<5) + 18,
(1<<15) + (19<<10) + (20<<5) + 21,
(0<<15) + (22<<10) + (23<<5) + 24};
vector signed short vss = {-4,-3,-2,-1,0,1,2,3};
vector bool short vbs = {0,65535,65535,0,0,0,65535,0};
/* Result vectors. */
vector signed short vsch, vscl;
vector bool short vbsh, vbsl;
vector unsigned int vuih, vuil;
vector signed int vsih, vsil;
vector bool int vbih, vbil;
/* Expected result vectors. */
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
vector signed short vschr = {0,1,2,3,4,5,6,7};
vector signed short vsclr = {-8,-7,-6,-5,-4,-3,-2,-1};
vector bool short vbshr = {65535,0,0,65535,65535,65535,0,65535};
vector bool short vbslr = {0,65535,65535,0,0,0,65535,0};
vector unsigned int vuihr = {(65535<<24) + (13<<16) + (14<<8) + 15,
(0<<24) + (16<<16) + (17<<8) + 18,
(65535<<24) + (19<<16) + (20<<8) + 21,
(0<<24) + (22<<16) + (23<<8) + 24};
vector unsigned int vuilr = {(0<<24) + (1<<16) + (2<<8) + 3,
(65535<<24) + (4<<16) + (5<<8) + 6,
(0<<24) + (7<<16) + (8<<8) + 9,
(65535<<24) + (10<<16) + (11<<8) + 12};
vector signed int vsihr = {0,1,2,3};
vector signed int vsilr = {-4,-3,-2,-1};
vector bool int vbihr = {0,0,BIG,0};
vector bool int vbilr = {0,BIG,BIG,0};
#else
vector signed short vschr = {-8,-7,-6,-5,-4,-3,-2,-1};
vector signed short vsclr = {0,1,2,3,4,5,6,7};
vector bool short vbshr = {0,65535,65535,0,0,0,65535,0};
vector bool short vbslr = {65535,0,0,65535,65535,65535,0,65535};
vector unsigned int vuihr = {(0<<24) + (1<<16) + (2<<8) + 3,
(65535<<24) + (4<<16) + (5<<8) + 6,
(0<<24) + (7<<16) + (8<<8) + 9,
(65535<<24) + (10<<16) + (11<<8) + 12};
vector unsigned int vuilr = {(65535<<24) + (13<<16) + (14<<8) + 15,
(0<<24) + (16<<16) + (17<<8) + 18,
(65535<<24) + (19<<16) + (20<<8) + 21,
(0<<24) + (22<<16) + (23<<8) + 24};
vector signed int vsihr = {-4,-3,-2,-1};
vector signed int vsilr = {0,1,2,3};
vector bool int vbihr = {0,BIG,BIG,0};
vector bool int vbilr = {0,0,BIG,0};
#endif
vsch = vec_unpackh (vsc);
vscl = vec_unpackl (vsc);
vbsh = vec_unpackh (vbc);
vbsl = vec_unpackl (vbc);
vuih = vec_unpackh (vp);
vuil = vec_unpackl (vp);
vsih = vec_unpackh (vss);
vsil = vec_unpackl (vss);
vbih = vec_unpackh (vbs);
vbil = vec_unpackl (vbs);
check (vec_all_eq (vsch, vschr), "vsch");
check (vec_all_eq (vscl, vsclr), "vscl");
check (vec_all_eq (vbsh, vbshr), "vbsh");
check (vec_all_eq (vbsl, vbslr), "vbsl");
check (vec_all_eq (vuih, vuihr), "vuih");
check (vec_all_eq (vuil, vuilr), "vuil");
check (vec_all_eq (vsih, vsihr), "vsih");
check (vec_all_eq (vsil, vsilr), "vsil");
check (vec_all_eq (vbih, vbihr), "vbih");
check (vec_all_eq (vbil, vbilr), "vbil");
}
// CHECK-LABEL: define void @test1
void test1() {
/* vec_cmpeq */
res_vbll = vec_cmpeq(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd
// CHECK-LE: @llvm.ppc.altivec.vcmpequd
// CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous
res_vbll = vec_cmpeq(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd
// CHECK-LE: @llvm.ppc.altivec.vcmpequd
// CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous
/* vec_cmpgt */
res_vbll = vec_cmpgt(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd
// CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous
res_vbll = vec_cmpgt(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud
// CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous
/* ----------------------- predicates --------------------------- */
/* vec_all_eq */
res_i = vec_all_eq(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
res_i = vec_all_eq(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
res_i = vec_all_eq(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
res_i = vec_all_eq(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
res_i = vec_all_eq(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
res_i = vec_all_eq(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
res_i = vec_all_eq(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_eq' is ambiguous
/* vec_all_ne */
res_i = vec_all_ne(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
res_i = vec_all_ne(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
res_i = vec_all_ne(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
res_i = vec_all_ne(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
res_i = vec_all_ne(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
res_i = vec_all_ne(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
res_i = vec_all_ne(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
/* vec_any_eq */
res_i = vec_any_eq(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
res_i = vec_any_eq(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
res_i = vec_any_eq(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
res_i = vec_any_eq(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
res_i = vec_any_eq(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
res_i = vec_any_eq(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
res_i = vec_any_eq(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_eq' is ambiguous
/* vec_any_ne */
res_i = vec_any_ne(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
res_i = vec_any_ne(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
res_i = vec_any_ne(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
res_i = vec_any_ne(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
res_i = vec_any_ne(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
res_i = vec_any_ne(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
res_i = vec_any_ne(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpequd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
// CHECK-PPC: error: call to 'vec_any_ne' is ambiguous
/* vec_all_ge */
res_i = vec_all_ge(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
res_i = vec_all_ge(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
res_i = vec_all_ge(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
res_i = vec_all_ge(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
res_i = vec_all_ge(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
res_i = vec_all_ge(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
res_i = vec_all_ge(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
/* vec_all_gt */
res_i = vec_all_gt(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
res_i = vec_all_gt(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
res_i = vec_all_gt(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
res_i = vec_all_gt(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
res_i = vec_all_gt(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
res_i = vec_all_gt(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
res_i = vec_all_gt(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
/* vec_all_le */
res_i = vec_all_le(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
res_i = vec_all_le(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
res_i = vec_all_le(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
res_i = vec_all_le(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
res_i = vec_all_le(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
res_i = vec_all_le(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
res_i = vec_all_le(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_le' is ambiguous
/* vec_all_lt */
res_i = vec_all_lt(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
res_i = vec_all_lt(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
res_i = vec_all_lt(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
res_i = vec_all_lt(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
res_i = vec_all_lt(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
res_i = vec_all_lt(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
res_i = vec_all_lt(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
/* vec_any_ge */
res_i = vec_any_ge(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
res_i = vec_any_ge(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
res_i = vec_any_ge(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
res_i = vec_any_ge(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
res_i = vec_any_ge(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
res_i = vec_any_ge(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
res_i = vec_any_ge(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
/* vec_any_gt */
res_i = vec_any_gt(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
res_i = vec_any_gt(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
res_i = vec_any_gt(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
res_i = vec_any_gt(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
res_i = vec_any_gt(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
res_i = vec_any_gt(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
res_i = vec_any_gt(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
/* vec_any_le */
res_i = vec_any_le(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
res_i = vec_any_le(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
res_i = vec_any_le(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
res_i = vec_any_le(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
res_i = vec_any_le(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
res_i = vec_any_le(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
res_i = vec_any_le(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_le' is ambiguous
/* vec_any_lt */
res_i = vec_any_lt(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
res_i = vec_any_lt(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
res_i = vec_any_lt(vull, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
res_i = vec_any_lt(vull, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
res_i = vec_any_lt(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
res_i = vec_any_lt(vbll, vull);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
res_i = vec_any_lt(vbll, vbll);
// CHECK: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
// CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
/* vec_max */
res_vsll = vec_max(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vmaxsd
// CHECK-LE: @llvm.ppc.altivec.vmaxsd
// CHECK-PPC: error: call to 'vec_max' is ambiguous
res_vsll = vec_max(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vmaxsd
// CHECK-LE: @llvm.ppc.altivec.vmaxsd
// CHECK-PPC: error: call to 'vec_max' is ambiguous
res_vsll = vec_max(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vmaxsd
// CHECK-LE: @llvm.ppc.altivec.vmaxsd
// CHECK-PPC: error: call to 'vec_max' is ambiguous
res_vull = vec_max(vull, vull);
// CHECK: @llvm.ppc.altivec.vmaxud
// CHECK-LE: @llvm.ppc.altivec.vmaxud
// CHECK-PPC: error: call to 'vec_max' is ambiguous
res_vull = vec_max(vbll, vull);
// CHECK: @llvm.ppc.altivec.vmaxud
// CHECK-LE: @llvm.ppc.altivec.vmaxud
// CHECK-PPC: error: call to 'vec_max' is ambiguous
res_vull = vec_max(vull, vbll);
// CHECK: @llvm.ppc.altivec.vmaxud
// CHECK-LE: @llvm.ppc.altivec.vmaxud
// CHECK-PPC: error: call to 'vec_max' is ambiguous
/* vec_min */
res_vsll = vec_min(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vminsd
// CHECK-LE: @llvm.ppc.altivec.vminsd
// CHECK-PPC: error: call to 'vec_min' is ambiguous
res_vsll = vec_min(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vminsd
// CHECK-LE: @llvm.ppc.altivec.vminsd
// CHECK-PPC: error: call to 'vec_min' is ambiguous
res_vsll = vec_min(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vminsd
// CHECK-LE: @llvm.ppc.altivec.vminsd
// CHECK-PPC: error: call to 'vec_min' is ambiguous
res_vull = vec_min(vull, vull);
// CHECK: @llvm.ppc.altivec.vminud
// CHECK-LE: @llvm.ppc.altivec.vminud
// CHECK-PPC: error: call to 'vec_min' is ambiguous
res_vull = vec_min(vbll, vull);
// CHECK: @llvm.ppc.altivec.vminud
// CHECK-LE: @llvm.ppc.altivec.vminud
// CHECK-PPC: error: call to 'vec_min' is ambiguous
res_vull = vec_min(vull, vbll);
// CHECK: @llvm.ppc.altivec.vminud
// CHECK-LE: @llvm.ppc.altivec.vminud
// CHECK-PPC: error: call to 'vec_min' is ambiguous
/* vec_mule */
res_vsll = vec_mule(vi, vi);
// CHECK: @llvm.ppc.altivec.vmulesw
// CHECK-LE: @llvm.ppc.altivec.vmulosw
// CHECK-PPC: error: call to 'vec_mule' is ambiguous
res_vull = vec_mule(vui , vui);
// CHECK: @llvm.ppc.altivec.vmuleuw
// CHECK-LE: @llvm.ppc.altivec.vmulouw
// CHECK-PPC: error: call to 'vec_mule' is ambiguous
/* vec_mulo */
res_vsll = vec_mulo(vi, vi);
// CHECK: @llvm.ppc.altivec.vmulosw
// CHECK-LE: @llvm.ppc.altivec.vmulesw
// CHECK-PPC: error: call to 'vec_mulo' is ambiguous
res_vull = vec_mulo(vui, vui);
// CHECK: @llvm.ppc.altivec.vmulouw
// CHECK-LE: @llvm.ppc.altivec.vmuleuw
// CHECK-PPC: error: call to 'vec_mulo' is ambiguous
/* vec_packs */
res_vi = vec_packs(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vpksdss
// CHECK-LE: @llvm.ppc.altivec.vpksdss
// CHECK-PPC: error: call to 'vec_packs' is ambiguous
res_vui = vec_packs(vull, vull);
// CHECK: @llvm.ppc.altivec.vpkudus
// CHECK-LE: @llvm.ppc.altivec.vpkudus
// CHECK-PPC: error: call to 'vec_packs' is ambiguous
/* vec_packsu */
res_vui = vec_packsu(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vpksdus
// CHECK-LE: @llvm.ppc.altivec.vpksdus
// CHECK-PPC: error: call to 'vec_packsu' is ambiguous
res_vui = vec_packsu(vull, vull);
// CHECK: @llvm.ppc.altivec.vpkudus
// CHECK-LE: @llvm.ppc.altivec.vpkudus
// CHECK-PPC: error: call to 'vec_packsu' is ambiguous
/* vec_rl */
res_vsll = vec_rl(vsll, vull);
// CHECK: @llvm.ppc.altivec.vrld
// CHECK-LE: @llvm.ppc.altivec.vrld
// CHECK-PPC: error: call to 'vec_rl' is ambiguous
res_vull = vec_rl(vull, vull);
// CHECK: @llvm.ppc.altivec.vrld
// CHECK-LE: @llvm.ppc.altivec.vrld
// CHECK-PPC: error: call to 'vec_rl' is ambiguous
/* vec_sl */
res_vsll = vec_sl(vsll, vull);
// CHECK: shl <2 x i64>
// CHECK-LE: shl <2 x i64>
// CHECK-PPC: error: call to 'vec_sl' is ambiguous
res_vull = vec_sl(vull, vull);
// CHECK: shl <2 x i64>
// CHECK-LE: shl <2 x i64>
// CHECK-PPC: error: call to 'vec_sl' is ambiguous
/* vec_sr */
res_vsll = vec_sr(vsll, vull);
// CHECK: ashr <2 x i64>
// CHECK-LE: ashr <2 x i64>
// CHECK-PPC: error: call to 'vec_sr' is ambiguous
res_vull = vec_sr(vull, vull);
// CHECK: lshr <2 x i64>
// CHECK-LE: lshr <2 x i64>
// CHECK-PPC: error: call to 'vec_sr' is ambiguous
/* vec_sra */
res_vsll = vec_sra(vsll, vull);
// CHECK: ashr <2 x i64>
// CHECK-LE: ashr <2 x i64>
// CHECK-PPC: error: call to 'vec_sra' is ambiguous
res_vull = vec_sra(vull, vull);
// CHECK: ashr <2 x i64>
// CHECK-LE: ashr <2 x i64>
// CHECK-PPC: error: call to 'vec_sra' is ambiguous
/* vec_unpackh */
res_vsll = vec_unpackh(vi);
// CHECK: llvm.ppc.altivec.vupkhsw
// CHECK-LE: llvm.ppc.altivec.vupklsw
// CHECK-PPC: error: call to 'vec_unpackh' is ambiguous
res_vbll = vec_unpackh(vbi);
// CHECK: llvm.ppc.altivec.vupkhsw
// CHECK-LE: llvm.ppc.altivec.vupklsw
// CHECK-PPC: error: call to 'vec_unpackh' is ambiguous
/* vec_unpackl */
res_vsll = vec_unpackl(vi);
// CHECK: llvm.ppc.altivec.vupklsw
// CHECK-LE: llvm.ppc.altivec.vupkhsw
// CHECK-PPC: error: call to 'vec_unpackl' is ambiguous
res_vbll = vec_unpackl(vbi);
// CHECK: llvm.ppc.altivec.vupklsw
// CHECK-LE: llvm.ppc.altivec.vupkhsw
// CHECK-PPC: error: call to 'vec_unpackl' is ambiguous
/* vec_vpksdss */
res_vi = vec_vpksdss(vsll, vsll);
// CHECK: llvm.ppc.altivec.vpksdss
// CHECK-LE: llvm.ppc.altivec.vpksdss
// CHECK-PPC: warning: implicit declaration of function 'vec_vpksdss'
/* vec_vpksdus */
res_vui = vec_vpksdus(vsll, vsll);
// CHECK: llvm.ppc.altivec.vpksdus
// CHECK-LE: llvm.ppc.altivec.vpksdus
// CHECK-PPC: warning: implicit declaration of function 'vec_vpksdus'
/* vec_vpkudum */
res_vi = vec_vpkudum(vsll, vsll);
// CHECK: vperm
// CHECK-LE: vperm
// CHECK-PPC: warning: implicit declaration of function 'vec_vpkudum'
res_vui = vec_vpkudum(vull, vull);
// CHECK: vperm
// CHECK-LE: vperm
res_vui = vec_vpkudus(vull, vull);
// CHECK: llvm.ppc.altivec.vpkudus
// CHECK-LE: llvm.ppc.altivec.vpkudus
// CHECK-PPC: warning: implicit declaration of function 'vec_vpkudus'
/* vec_vupkhsw */
res_vsll = vec_vupkhsw(vi);
// CHECK: llvm.ppc.altivec.vupkhsw
// CHECK-LE: llvm.ppc.altivec.vupklsw
// CHECK-PPC: warning: implicit declaration of function 'vec_vupkhsw'
res_vbll = vec_vupkhsw(vbi);
// CHECK: llvm.ppc.altivec.vupkhsw
// CHECK-LE: llvm.ppc.altivec.vupklsw
/* vec_vupklsw */
res_vsll = vec_vupklsw(vi);
// CHECK: llvm.ppc.altivec.vupklsw
// CHECK-LE: llvm.ppc.altivec.vupkhsw
// CHECK-PPC: warning: implicit declaration of function 'vec_vupklsw'
res_vbll = vec_vupklsw(vbi);
// CHECK: llvm.ppc.altivec.vupklsw
// CHECK-LE: llvm.ppc.altivec.vupkhsw
/* vec_max */
res_vsll = vec_max(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vmaxsd
// CHECK-LE: @llvm.ppc.altivec.vmaxsd
res_vsll = vec_max(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vmaxsd
// CHECK-LE: @llvm.ppc.altivec.vmaxsd
res_vsll = vec_max(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vmaxsd
// CHECK-LE: @llvm.ppc.altivec.vmaxsd
res_vull = vec_max(vull, vull);
// CHECK: @llvm.ppc.altivec.vmaxud
// CHECK-LE: @llvm.ppc.altivec.vmaxud
res_vull = vec_max(vbll, vull);
// CHECK: @llvm.ppc.altivec.vmaxud
// CHECK-LE: @llvm.ppc.altivec.vmaxud
/* vec_min */
res_vsll = vec_min(vsll, vsll);
// CHECK: @llvm.ppc.altivec.vminsd
// CHECK-LE: @llvm.ppc.altivec.vminsd
res_vsll = vec_min(vbll, vsll);
// CHECK: @llvm.ppc.altivec.vminsd
// CHECK-LE: @llvm.ppc.altivec.vminsd
res_vsll = vec_min(vsll, vbll);
// CHECK: @llvm.ppc.altivec.vminsd
// CHECK-LE: @llvm.ppc.altivec.vminsd
res_vull = vec_min(vull, vull);
// CHECK: @llvm.ppc.altivec.vminud
// CHECK-LE: @llvm.ppc.altivec.vminud
res_vull = vec_min(vbll, vull);
// CHECK: @llvm.ppc.altivec.vminud
// CHECK-LE: @llvm.ppc.altivec.vminud
}
/*
* NAME: sha256->search()
* DESCRIPTION: try to find a nonce which satisfies a target hash
*/
int64_t sha256_search(const message_t M,
const hash_t target, const hash_t midstate,
uint32_t start_nonce, uint32_t range)
{
uint32_t nonce, stop_nonce = start_nonce + range + (4 - (range % 4)) % 4;
# if !defined(UNROLL_SHA256)
int t;
# endif
vec_uint4 W0[3], a0, b0, c0, d0, e0, f0, g0, h0;
vec_uint4 W[16], a, b, c, d, e, f, g, h, T1, T2;
vec_uint4 borrow;
const vec_uchar16 reverse_endian = {
3, 2, 1, 0,
7, 6, 5, 4,
11, 10, 9, 8,
15, 14, 13, 12
};
/* precompute first three rounds */
a = SPLAT(midstate.words[0]);
b = SPLAT(midstate.words[1]);
c = SPLAT(midstate.words[2]);
d = SPLAT(midstate.words[3]);
e = SPLAT(midstate.words[4]);
f = SPLAT(midstate.words[5]);
g = SPLAT(midstate.words[6]);
h = SPLAT(midstate.words[7]);
# ifdef UNROLL_SHA256
W[0] = SPLAT(M.words[0]); ROUND(0);
W[1] = SPLAT(M.words[1]); ROUND(1);
W[2] = SPLAT(M.words[2]); ROUND(2);
# else
for (t = 0; t < 3; ++t) {
W[t] = SPLAT(M.words[t]);
ROUND(t);
}
# endif
W0[0] = W[0];
W0[1] = W[1];
W0[2] = W[2];
a0 = a;
b0 = b;
c0 = c;
d0 = d;
e0 = e;
f0 = f;
g0 = g;
h0 = h;
/* do the search, four at a time */
for (nonce = start_nonce; nonce != stop_nonce; nonce += 4) {
W[0] = W0[0];
W[1] = W0[1];
W[2] = W0[2];
a = a0;
b = b0;
c = c0;
d = d0;
e = e0;
f = f0;
g = g0;
h = h0;
/* t = 3 */
W[3] = (vec_uint4) { nonce + 0, nonce + 1, nonce + 2, nonce + 3 };
ROUND(3);
# ifdef UNROLL_SHA256
W[ 4] = SPLAT(M.words[ 4]); ROUND( 4);
W[ 5] = SPLAT(M.words[ 5]); ROUND( 5);
W[ 6] = SPLAT(M.words[ 6]); ROUND( 6);
W[ 7] = SPLAT(M.words[ 7]); ROUND( 7);
W[ 8] = SPLAT(M.words[ 8]); ROUND( 8);
W[ 9] = SPLAT(M.words[ 9]); ROUND( 9);
W[10] = SPLAT(M.words[10]); ROUND(10);
W[11] = SPLAT(M.words[11]); ROUND(11);
W[12] = SPLAT(M.words[12]); ROUND(12);
W[13] = SPLAT(M.words[13]); ROUND(13);
W[14] = SPLAT(M.words[14]); ROUND(14);
W[15] = SPLAT(M.words[15]); ROUND(15);
# else
for (t = 4; t < 16; ++t) {
W[t] = SPLAT(M.words[t]);
ROUND(t);
}
# endif
# ifdef UNROLL_SHA256
W[16 % 16] = W(16); ROUND(16);
W[17 % 16] = W(17); ROUND(17);
W[18 % 16] = W(18); ROUND(18);
W[19 % 16] = W(19); ROUND(19);
W[20 % 16] = W(20); ROUND(20);
W[21 % 16] = W(21); ROUND(21);
W[22 % 16] = W(22); ROUND(22);
W[23 % 16] = W(23); ROUND(23);
W[24 % 16] = W(24); ROUND(24);
W[25 % 16] = W(25); ROUND(25);
W[26 % 16] = W(26); ROUND(26);
W[27 % 16] = W(27); ROUND(27);
W[28 % 16] = W(28); ROUND(28);
W[29 % 16] = W(29); ROUND(29);
W[30 % 16] = W(30); ROUND(30);
W[31 % 16] = W(31); ROUND(31);
W[32 % 16] = W(32); ROUND(32);
W[33 % 16] = W(33); ROUND(33);
W[34 % 16] = W(34); ROUND(34);
W[35 % 16] = W(35); ROUND(35);
W[36 % 16] = W(36); ROUND(36);
W[37 % 16] = W(37); ROUND(37);
W[38 % 16] = W(38); ROUND(38);
W[39 % 16] = W(39); ROUND(39);
W[40 % 16] = W(40); ROUND(40);
W[41 % 16] = W(41); ROUND(41);
W[42 % 16] = W(42); ROUND(42);
W[43 % 16] = W(43); ROUND(43);
W[44 % 16] = W(44); ROUND(44);
W[45 % 16] = W(45); ROUND(45);
W[46 % 16] = W(46); ROUND(46);
W[47 % 16] = W(47); ROUND(47);
W[48 % 16] = W(48); ROUND(48);
W[49 % 16] = W(49); ROUND(49);
W[50 % 16] = W(50); ROUND(50);
W[51 % 16] = W(51); ROUND(51);
W[52 % 16] = W(52); ROUND(52);
W[53 % 16] = W(53); ROUND(53);
W[54 % 16] = W(54); ROUND(54);
W[55 % 16] = W(55); ROUND(55);
W[56 % 16] = W(56); ROUND(56);
W[57 % 16] = W(57); ROUND(57);
W[58 % 16] = W(58); ROUND(58);
W[59 % 16] = W(59); ROUND(59);
W[60 % 16] = W(60); ROUND(60);
W[61 % 16] = W(61); ROUND(61);
W[62 % 16] = W(62); ROUND(62);
W[63 % 16] = W(63); ROUND(63);
# else
for (t = 16; t < 64; ++t) {
W[t % 16] = W(t);
ROUND(t);
}
# endif
W[0] = ADD(a, SPLAT(midstate.words[0]));
W[1] = ADD(b, SPLAT(midstate.words[1]));
W[2] = ADD(c, SPLAT(midstate.words[2]));
W[3] = ADD(d, SPLAT(midstate.words[3]));
W[4] = ADD(e, SPLAT(midstate.words[4]));
W[5] = ADD(f, SPLAT(midstate.words[5]));
W[6] = ADD(g, SPLAT(midstate.words[6]));
W[7] = ADD(h, SPLAT(midstate.words[7]));
/* first SHA-256 complete */
a = SPLAT(H0.words[0]);
b = SPLAT(H0.words[1]);
c = SPLAT(H0.words[2]);
d = SPLAT(H0.words[3]);
e = SPLAT(H0.words[4]);
f = SPLAT(H0.words[5]);
g = SPLAT(H0.words[6]);
h = SPLAT(H0.words[7]);
ROUND(0);
ROUND(1);
ROUND(2);
ROUND(3);
ROUND(4);
ROUND(5);
ROUND(6);
ROUND(7);
W[ 8] = SPLAT(0x80000000U); ROUND( 8);
# ifdef UNROLL_SHA256
W[ 9] = SPLAT(0x00000000U); ROUND( 9);
W[10] = SPLAT(0x00000000U); ROUND(10);
W[11] = SPLAT(0x00000000U); ROUND(11);
W[12] = SPLAT(0x00000000U); ROUND(12);
W[13] = SPLAT(0x00000000U); ROUND(13);
W[14] = SPLAT(0x00000000U); ROUND(14);
# else
for (t = 9; t < 15; ++t) {
W[t] = SPLAT(0U);
ROUND(t);
}
# endif
W[15] = SPLAT(0x00000100U); ROUND(15);
# ifdef UNROLL_SHA256
W[16 % 16] = W(16); ROUND(16);
W[17 % 16] = W(17); ROUND(17);
W[18 % 16] = W(18); ROUND(18);
W[19 % 16] = W(19); ROUND(19);
W[20 % 16] = W(20); ROUND(20);
W[21 % 16] = W(21); ROUND(21);
W[22 % 16] = W(22); ROUND(22);
W[23 % 16] = W(23); ROUND(23);
W[24 % 16] = W(24); ROUND(24);
W[25 % 16] = W(25); ROUND(25);
W[26 % 16] = W(26); ROUND(26);
W[27 % 16] = W(27); ROUND(27);
W[28 % 16] = W(28); ROUND(28);
W[29 % 16] = W(29); ROUND(29);
W[30 % 16] = W(30); ROUND(30);
W[31 % 16] = W(31); ROUND(31);
W[32 % 16] = W(32); ROUND(32);
W[33 % 16] = W(33); ROUND(33);
W[34 % 16] = W(34); ROUND(34);
W[35 % 16] = W(35); ROUND(35);
W[36 % 16] = W(36); ROUND(36);
W[37 % 16] = W(37); ROUND(37);
W[38 % 16] = W(38); ROUND(38);
W[39 % 16] = W(39); ROUND(39);
W[40 % 16] = W(40); ROUND(40);
W[41 % 16] = W(41); ROUND(41);
W[42 % 16] = W(42); ROUND(42);
W[43 % 16] = W(43); ROUND(43);
W[44 % 16] = W(44); ROUND(44);
W[45 % 16] = W(45); ROUND(45);
W[46 % 16] = W(46); ROUND(46);
W[47 % 16] = W(47); ROUND(47);
W[48 % 16] = W(48); ROUND(48);
W[49 % 16] = W(49); ROUND(49);
W[50 % 16] = W(50); ROUND(50);
W[51 % 16] = W(51); ROUND(51);
W[52 % 16] = W(52); ROUND(52);
W[53 % 16] = W(53); ROUND(53);
W[54 % 16] = W(54); ROUND(54);
W[55 % 16] = W(55); ROUND(55);
W[56 % 16] = W(56); ROUND(56);
W[57 % 16] = W(57); ROUND(57);
W[58 % 16] = W(58); ROUND(58);
W[59 % 16] = W(59); ROUND(59);
/* t = 60..63 delayed */
# else
for (t = 16; t < 60; ++t) {
W[t % 16] = W(t);
ROUND(t);
}
# endif
W[60 % 16] = W(60);
T1 = T1(60, e, f, g, h);
T2 = ADD(ADD(d, T1), SPLAT(H0.words[7]));
/* quick check to see if any element of the last word vector is zero */
if (__builtin_expect(!vec_any_eq(T2, vec_splat_u32(0)), 1))
continue;
/* we have something interesting; finish the SHA-256 */
ROUND(60);
# ifdef UNROLL_SHA256
W[61 % 16] = W(61); ROUND(61);
W[62 % 16] = W(62); ROUND(62);
W[63 % 16] = W(63); ROUND(63);
# else
for (t = 61; t < 64; ++t) {
W[t % 16] = W(t);
ROUND(t);
}
# endif
a = ADD(a, SPLAT(H0.words[0]));
b = ADD(b, SPLAT(H0.words[1]));
c = ADD(c, SPLAT(H0.words[2]));
d = ADD(d, SPLAT(H0.words[3]));
e = ADD(e, SPLAT(H0.words[4]));
f = ADD(f, SPLAT(H0.words[5]));
g = ADD(g, SPLAT(H0.words[6]));
h = ADD(h, SPLAT(H0.words[7]));
/* now do the full (reversed-endian) subtraction */
borrow = GENB(SPLAT(target.words[7]),
vec_perm(a, a, reverse_endian));
borrow = GENBX(SPLAT(target.words[6]),
vec_perm(b, b, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[5]),
vec_perm(c, c, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[4]),
vec_perm(d, d, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[3]),
vec_perm(e, e, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[2]),
vec_perm(f, f, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[1]),
vec_perm(g, g, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[0]),
vec_perm(h, h, reverse_endian), borrow);
if (__builtin_expect(vec_all_eq(borrow, vec_splat_u32(0)), 1))
continue;
/* we have a winner */
if (vec_extract(borrow, 0))
return nonce + 0;
if (vec_extract(borrow, 1))
return nonce + 1;
if (vec_extract(borrow, 2))
return nonce + 2;
if (vec_extract(borrow, 3))
return nonce + 3;
}
return -1;
}
int foo(vector float x, vector float y) {
if (vec_all_eq(x,y)) return 3245;
else return 12;
}
void
jsimd_idct_islow_altivec (void * dct_table_, JCOEFPTR coef_block,
JSAMPARRAY output_buf, JDIMENSION output_col)
{
short *dct_table = (short *)dct_table_;
int *outptr;
__vector short row0, row1, row2, row3, row4, row5, row6, row7,
col0, col1, col2, col3, col4, col5, col6, col7,
quant0, quant1, quant2, quant3, quant4, quant5, quant6, quant7,
tmp0, tmp1, tmp2, tmp3, z3, z4,
z34l, z34h, col71l, col71h, col26l, col26h, col53l, col53h,
row71l, row71h, row26l, row26h, row53l, row53h,
out0, out1, out2, out3, out4, out5, out6, out7;
__vector int tmp0l, tmp0h, tmp1l, tmp1h, tmp2l, tmp2h, tmp3l, tmp3h,
tmp10l, tmp10h, tmp11l, tmp11h, tmp12l, tmp12h, tmp13l, tmp13h,
z3l, z3h, z4l, z4h,
out0l, out0h, out1l, out1h, out2l, out2h, out3l, out3h, out4l, out4h,
out5l, out5h, out6l, out6h, out7l, out7h;
__vector signed char outb;
/* Constants */
__vector short pw_zero = { __8X(0) },
pw_f130_f054 = { __4X2(F_0_541 + F_0_765, F_0_541) },
pw_f054_mf130 = { __4X2(F_0_541, F_0_541 - F_1_847) },
pw_mf078_f117 = { __4X2(F_1_175 - F_1_961, F_1_175) },
pw_f117_f078 = { __4X2(F_1_175, F_1_175 - F_0_390) },
pw_mf060_mf089 = { __4X2(F_0_298 - F_0_899, -F_0_899) },
pw_mf089_f060 = { __4X2(-F_0_899, F_1_501 - F_0_899) },
pw_mf050_mf256 = { __4X2(F_2_053 - F_2_562, -F_2_562) },
pw_mf256_f050 = { __4X2(-F_2_562, F_3_072 - F_2_562) };
__vector unsigned short pass1_bits = { __8X(PASS1_BITS) };
__vector int pd_zero = { __4X(0) },
pd_descale_p1 = { __4X(1 << (DESCALE_P1 - 1)) },
pd_descale_p2 = { __4X(1 << (DESCALE_P2 - 1)) };
__vector unsigned int descale_p1 = { __4X(DESCALE_P1) },
descale_p2 = { __4X(DESCALE_P2) },
const_bits = { __4X(CONST_BITS) };
__vector signed char pb_centerjsamp = { __16X(CENTERJSAMPLE) };
/* Pass 1: process columns */
col0 = vec_ld(0, coef_block);
col1 = vec_ld(16, coef_block);
col2 = vec_ld(32, coef_block);
col3 = vec_ld(48, coef_block);
col4 = vec_ld(64, coef_block);
col5 = vec_ld(80, coef_block);
col6 = vec_ld(96, coef_block);
col7 = vec_ld(112, coef_block);
tmp1 = vec_or(col1, col2);
tmp2 = vec_or(col3, col4);
tmp1 = vec_or(tmp1, tmp2);
tmp3 = vec_or(col5, col6);
tmp3 = vec_or(tmp3, col7);
tmp1 = vec_or(tmp1, tmp3);
quant0 = vec_ld(0, dct_table);
col0 = vec_mladd(col0, quant0, pw_zero);
if (vec_all_eq(tmp1, pw_zero)) {
/* AC terms all zero */
col0 = vec_sl(col0, pass1_bits);
row0 = vec_splat(col0, 0);
row1 = vec_splat(col0, 1);
row2 = vec_splat(col0, 2);
row3 = vec_splat(col0, 3);
row4 = vec_splat(col0, 4);
row5 = vec_splat(col0, 5);
row6 = vec_splat(col0, 6);
row7 = vec_splat(col0, 7);
} else {
quant1 = vec_ld(16, dct_table);
quant2 = vec_ld(32, dct_table);
quant3 = vec_ld(48, dct_table);
quant4 = vec_ld(64, dct_table);
quant5 = vec_ld(80, dct_table);
quant6 = vec_ld(96, dct_table);
quant7 = vec_ld(112, dct_table);
col1 = vec_mladd(col1, quant1, pw_zero);
col2 = vec_mladd(col2, quant2, pw_zero);
col3 = vec_mladd(col3, quant3, pw_zero);
col4 = vec_mladd(col4, quant4, pw_zero);
col5 = vec_mladd(col5, quant5, pw_zero);
col6 = vec_mladd(col6, quant6, pw_zero);
col7 = vec_mladd(col7, quant7, pw_zero);
DO_IDCT(col, 1);
TRANSPOSE(out, row);
}
/* Pass 2: process rows */
DO_IDCT(row, 2);
TRANSPOSE(out, col);
outb = vec_packs(col0, col0);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[0] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col1, col1);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[1] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col2, col2);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[2] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col3, col3);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[3] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col4, col4);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[4] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col5, col5);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[5] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col6, col6);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[6] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
outb = vec_packs(col7, col7);
outb = vec_add(outb, pb_centerjsamp);
outptr = (int *)(output_buf[7] + output_col);
vec_ste((__vector int)outb, 0, outptr);
vec_ste((__vector int)outb, 4, outptr);
}
static void test()
{
static vector unsigned int zero;
check(vec_all_eq(funny(), zero), "funny");
}
static void test ()
{
vector unsigned char evuc = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
vector signed char evsc = {-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7};
vector bool char evbc = {0,255,0,255,0,255,0,255,0,255,0,255,0,255,0,255};
vector unsigned short evus = {0,1,2,3,4,5,6,7};
vector signed short evss = {-4,-3,-2,-1,0,1,2,3};
vector bool short evbs = {0,65535,0,65535,0,65535,0,65535};
vector pixel evp = {0,1,2,3,4,5,6,7};
vector unsigned int evui = {0,1,2,3};
vector signed int evsi = {-2,-1,0,1};
vector bool int evbi = {0,0xffffffff,0,0xffffffff};
vector float evf = {0.0,1.0,2.0,3.0};
vector unsigned char vuc;
vector signed char vsc;
vector bool char vbc;
vector unsigned short vus;
vector signed short vss;
vector bool short vbs;
vector pixel vp;
vector unsigned int vui;
vector signed int vsi;
vector bool int vbi;
vector float vf;
init ();
vuc = vec_ld (0, (vector unsigned char *)svuc);
vsc = vec_ld (0, (vector signed char *)svsc);
vbc = vec_ld (0, (vector bool char *)svbc);
vus = vec_ld (0, (vector unsigned short *)svus);
vss = vec_ld (0, (vector signed short *)svss);
vbs = vec_ld (0, (vector bool short *)svbs);
vp = vec_ld (0, (vector pixel *)svp);
vui = vec_ld (0, (vector unsigned int *)svui);
vsi = vec_ld (0, (vector signed int *)svsi);
vbi = vec_ld (0, (vector bool int *)svbi);
vf = vec_ld (0, (vector float *)svf);
check (vec_all_eq (vuc, evuc), "vuc");
check (vec_all_eq (vsc, evsc), "vsc");
check (vec_all_eq (vbc, evbc), "vbc");
check (vec_all_eq (vus, evus), "vus");
check (vec_all_eq (vss, evss), "vss");
check (vec_all_eq (vbs, evbs), "vbs");
check (vec_all_eq (vp, evp ), "vp" );
check (vec_all_eq (vui, evui), "vui");
check (vec_all_eq (vsi, evsi), "vsi");
check (vec_all_eq (vbi, evbi), "vbi");
check (vec_all_eq (vf, evf ), "vf" );
}
