Skip to content

R
riscv-gcc-1
Commit cf989997 by Richard Henderson Committed by Richard Henderson
Options

Rework vector shuffle tests. 

Test vector sizes 8, 16, and 32.  Test most data types for each size.

From-SVN: r179623
parent 8864db87
Showing with 526 additions and 460 deletions
gcc/testsuite/ChangeLog
2011-10-06 Richard Henderson <rth@redhat.com>
* gcc.c-torture/execute/vect-shuffle-1.c: Remove.
* gcc.c-torture/execute/vect-shuffle-2.c: Remove.
* gcc.c-torture/execute/vect-shuffle-3.c: Remove.
* gcc.c-torture/execute/vect-shuffle-4.c: Remove.
* gcc.c-torture/execute/vect-shuffle-5.c: Remove.
* gcc.c-torture/execute/vect-shuffle-6.c: Remove.
* gcc.c-torture/execute/vect-shuffle-7.c: Remove.
* gcc.c-torture/execute/vect-shuffle-8.c: Remove.
* gcc.c-torture/execute/vshuf-16.inc: New file.
* gcc.c-torture/execute/vshuf-2.inc: New file.
* gcc.c-torture/execute/vshuf-4.inc: New file.
* gcc.c-torture/execute/vshuf-8.inc: New file.
* gcc.c-torture/execute/vshuf-main.inc: New file.
* gcc.c-torture/execute/vshuf-v16qi.c: New test.
* gcc.c-torture/execute/vshuf-v2df.c: New test.
* gcc.c-torture/execute/vshuf-v2di.c: New test.
* gcc.c-torture/execute/vshuf-v2sf.c: New test.
* gcc.c-torture/execute/vshuf-v2si.c: New test.
* gcc.c-torture/execute/vshuf-v4df.c: New test.
* gcc.c-torture/execute/vshuf-v4di.c: New test.
* gcc.c-torture/execute/vshuf-v4hi.c: New test.
* gcc.c-torture/execute/vshuf-v4sf.c: New test.
* gcc.c-torture/execute/vshuf-v4si.c: New test.
* gcc.c-torture/execute/vshuf-v8hi.c: New test.
* gcc.c-torture/execute/vshuf-v8qi.c: New test.
* gcc.c-torture/execute/vshuf-v8si.c: New test.
2011-10-06 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/49279
......
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-1.c deleted 100644 → 0
#if __SIZEOF_INT__ == 4
typedef unsigned int V __attribute__((vector_size(16), may_alias));
struct S
{
V in, mask, out;
};
struct S tests[] = {
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0, 1, 2, 3 },
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0+1*4, 1+2*4, 2+3*4, 3+4*4 },
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 3, 2, 1, 0 },
{ 0x44444444, 0x33333333, 0x22222222, 0x11111111 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0, 3, 2, 1 },
{ 0x11111111, 0x44444444, 0x33333333, 0x22222222 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0, 2, 1, 3 },
{ 0x11111111, 0x33333333, 0x22222222, 0x44444444 },
},
{
{ 0x11223344, 0x55667788, 0x99aabbcc, 0xddeeff00 },
{ 3, 1, 2, 0 },
{ 0xddeeff00, 0x55667788, 0x99aabbcc, 0x11223344 },
},
{
{ 0x11223344, 0x55667788, 0x99aabbcc, 0xddeeff00 },
{ 0, 0, 0, 0 },
{ 0x11223344, 0x11223344, 0x11223344, 0x11223344 },
},
{
{ 0x11223344, 0x55667788, 0x99aabbcc, 0xddeeff00 },
{ 1, 2, 1, 2 },
{ 0x55667788, 0x99aabbcc, 0x55667788, 0x99aabbcc },
}
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif /* SIZEOF_INT */
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-2.c deleted 100644 → 0
#if __SIZEOF_SHORT__ == 2
typedef unsigned short V __attribute__((vector_size(16), may_alias));
struct S
{
V in, mask, out;
};
struct S tests[] = {
{
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
{ 0, 1, 2, 3, 4, 5, 6, 7 },
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
},
{
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
{ 0x10, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87 },
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
},
{
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
{ 7, 6, 5, 4, 3, 2, 1, 0 },
{ 0x8888, 0x7777, 0x6666, 0x5555, 0x4444, 0x3333, 0x2222, 0x1111 },
},
{
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
{ 7, 0, 5, 3, 2, 4, 1, 6 },
{ 0x8888, 0x1111, 0x6666, 0x4444, 0x3333, 0x5555, 0x2222, 0x7777 },
},
{
{ 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888 },
{ 0, 2, 1, 3, 4, 6, 5, 7 },
{ 0x1111, 0x3333, 0x2222, 0x4444, 0x5555, 0x7777, 0x6666, 0x8888 },
},
{
{ 0x1122, 0x3344, 0x5566, 0x7788, 0x99aa, 0xbbcc, 0xddee, 0xff00 },
{ 3, 1, 2, 0, 7, 5, 6, 4 },
{ 0x7788, 0x3344, 0x5566, 0x1122, 0xff00, 0xbbcc, 0xddee, 0x99aa },
},
{
{ 0x1122, 0x3344, 0x5566, 0x7788, 0x99aa, 0xbbcc, 0xddee, 0xff00 },
{ 0, 0, 0, 0 },
{ 0x1122, 0x1122, 0x1122, 0x1122, 0x1122, 0x1122, 0x1122, 0x1122 },
},
{
{ 0x1122, 0x3344, 0x5566, 0x7788, 0x99aa, 0xbbcc, 0xddee, 0xff00 },
{ 1, 6, 1, 6, 1, 6, 1, 6 },
{ 0x3344, 0xddee, 0x3344, 0xddee, 0x3344, 0xddee, 0x3344, 0xddee },
}
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in, tests[i].mask);
if (memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif /* SIZEOF_SHORT */
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-3.c deleted 100644 → 0
#if __SIZEOF_LONG_LONG__ == 8
typedef unsigned long long V __attribute__((vector_size(16), may_alias));
struct S
{
V in, mask, out;
};
struct S tests[] = {
{
{ 0x1111111111111111, 0x2222222222222222 },
{ 0, 1 },
{ 0x1111111111111111, 0x2222222222222222 },
},
{
{ 0x1111111111111111, 0x2222222222222222 },
{ 0x0102030405060700, 0xffeeddccbbaa99f1 },
{ 0x1111111111111111, 0x2222222222222222 },
},
{
{ 0x1111111111111111, 0x2222222222222222 },
{ 1, 0 },
{ 0x2222222222222222, 0x1111111111111111 },
},
{
{ 0x1111111111111111, 0x2222222222222222 },
{ 0, 0 },
{ 0x1111111111111111, 0x1111111111111111 },
},
{
{ 0x1122334455667788, 0x99aabbccddeeff00 },
{ 1, 1 },
{ 0x99aabbccddeeff00, 0x99aabbccddeeff00 },
},
{
{ 0x1122334455667788, 0x99aabbccddeeff00 },
{ 1, 0 },
{ 0x99aabbccddeeff00, 0x1122334455667788 },
},
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif /* SIZEOF_LONG_LONG */
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-4.c deleted 100644 → 0
typedef unsigned char V __attribute__((vector_size(16), may_alias));
struct S
{
V in, mask, out;
};
struct S tests[] = {
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 0x10, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87,
0x98, 0xa9, 0xba, 0xcb, 0xdc, 0xed, 0xfe, 0xff },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
{ 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15 },
{ 1, 3, 5, 7, 9, 11, 13, 15, 2, 4, 6, 8, 10, 12, 14, 16 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 },
},
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in, tests[i].mask);
if (memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-5.c deleted 100644 → 0
#if __SIZEOF_INT__ == 4
typedef unsigned int V __attribute__((vector_size(16), may_alias));
struct S
{
V in1, in2, mask, out;
};
struct S tests[] = {
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
{ 0, 1, 2, 3 },
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
{ 4, 5, 6, 7 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
{ 0, 4, 1, 5 },
{ 0x11111111, 0x55555555, 0x22222222, 0x66666666 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
{ 0, 7, 4, 3 },
{ 0x11111111, 0x88888888, 0x55555555, 0x44444444 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
{ 0, 0, 0, 0 },
{ 0x11111111, 0x11111111, 0x11111111, 0x11111111 },
},
{
{ 0x11111111, 0x22222222, 0x33333333, 0x44444444 },
{ 0x55555555, 0x66666666, 0x77777777, 0x88888888 },
{ 7, 7, 7, 7 },
{ 0x88888888, 0x88888888, 0x88888888, 0x88888888 },
},
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in1, tests[i].in2, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif /* SIZEOF_INT */
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-6.c deleted 100644 → 0
#if __SIZEOF_SHORT__ == 2
typedef unsigned short V __attribute__((vector_size(16), may_alias));
struct S
{
V in1, in2, mask, out;
};
struct S tests[] = {
{
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
{ 0, 1, 2, 3, 4, 5, 6, 7 },
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
},
{
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
{ 8, 9, 10, 11, 12, 13, 14, 15 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
},
{
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
{ 0, 8, 1, 9, 2, 10, 3, 11 },
{ 0x1010, 0x9898, 0x2121, 0xa9a9, 0x3232, 0xbaba, 0x4343, 0xcbcb },
},
{
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
{ 0, 15, 4, 11, 12, 3, 7, 8 },
{ 0x1010, 0x0f0f, 0x5454, 0xcbcb, 0xdcdc, 0x4343, 0x8787, 0x9898 },
},
{
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0x1010, 0x1010, 0x1010, 0x1010, 0x1010, 0x1010, 0x1010, 0x1010 },
},
{
{ 0x1010, 0x2121, 0x3232, 0x4343, 0x5454, 0x6565, 0x7676, 0x8787 },
{ 0x9898, 0xa9a9, 0xbaba, 0xcbcb, 0xdcdc, 0xeded, 0xfefe, 0x0f0f },
{ 14, 14, 14, 14, 14, 14, 14, 14 },
{ 0xfefe, 0xfefe, 0xfefe, 0xfefe, 0xfefe, 0xfefe, 0xfefe, 0xfefe },
},
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in1, tests[i].in2, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif /* SIZEOF_SHORT */
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-7.c deleted 100644 → 0
#if __SIZEOF_LONG_LONG__ == 8
typedef unsigned long long V __attribute__((vector_size(16), may_alias));
struct S
{
V in1, in2, mask, out;
};
struct S tests[] = {
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 0, 1 },
{ 0x1112131415161718, 0x2122232425262728 },
},
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 2, 3 },
{ 0x3132333435363738, 0x4142434445464748 },
},
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 0, 2 },
{ 0x1112131415161718, 0x3132333435363738 },
},
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 2, 1 },
{ 0x3132333435363738, 0x2122232425262728 },
},
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 3, 0 },
{ 0x4142434445464748, 0x1112131415161718 },
},
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 0, 0 },
{ 0x1112131415161718, 0x1112131415161718 },
},
{
{ 0x1112131415161718, 0x2122232425262728 },
{ 0x3132333435363738, 0x4142434445464748 },
{ 3, 3 },
{ 0x4142434445464748, 0x4142434445464748 },
},
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in1, tests[i].in2, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif /* SIZEOF_LONG_LONG */
gcc/testsuite/gcc.c-torture/execute/vect-shuffle-8.c → gcc/testsuite/gcc.c-torture/execute/vshuf-16.inc
typedef unsigned char V __attribute__((vector_size(16), may_alias));
/* Test fragment for vectors with 16 elements. */
#ifndef UNSUPPORTED
struct S
{
V in1, in2, mask, out;
V in;
VI mask;
V out;
};
struct S tests[] = {
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 0x10, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87,
0x98, 0xa9, 0xba, 0xcb, 0xdc, 0xed, 0xfe, 0xff },
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
{ 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15 },
{ 1, 3, 5, 7, 9, 11, 13, 15, 2, 4, 6, 8, 10, 12, 14, 16 },
},
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 },
},
};
struct S2
{
V in1, in2;
VI mask;
V out;
};
struct S2 tests2[] = {
{
{ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 },
{ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
......@@ -38,18 +78,4 @@ struct S tests[] = {
},
};
extern void abort(void);
int main()
{
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in1, tests[i].in2, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
return 0;
}
#endif
gcc/testsuite/gcc.c-torture/execute/vshuf-2.inc 0 → 100644
/* Test fragment for vectors of 2 elements. */
#ifndef UNSUPPORTED
struct S
{
V in;
VI mask;
V out;
};
struct S tests[] = {
{ { A, B }, { 0, 1 }, { A, B } },
{ { A, B }, { -16, -1 }, { A, B } },
{ { A, B }, { 1, 0 }, { B, A } },
{ { A, B }, { 0, 0 }, { A, A } },
{ { X, Y }, { 1, 1 }, { Y, Y } },
{ { X, Y }, { 1, 0 }, { Y, X } },
};
struct S2
{
V in1, in2;
VI mask;
V out;
};
struct S2 tests2[] = {
{ { A, B }, { X, Y }, { 0, 1 }, { A, B } },
{ { A, B }, { X, Y }, { 2, 3 }, { X, Y } },
{ { A, B }, { X, Y }, { 0, 2 }, { A, X } },
{ { A, B }, { X, Y }, { 2, 1 }, { X, B } },
{ { A, B }, { X, Y }, { 3, 0 }, { Y, A } },
{ { A, B }, { X, Y }, { 0, 0 }, { A, A } },
{ { A, B }, { X, Y }, { 3, 3 }, { Y, Y } },
};
#endif
gcc/testsuite/gcc.c-torture/execute/vshuf-4.inc 0 → 100644
/* Test fragment for vectors of 4 elements. */
#ifndef UNSUPPORTED
struct S
{
V in;
VI mask;
V out;
};
struct S tests[] = {
{ { A, B, C, D }, { 0, 1, 2, 3 }, { A, B, C, D }, },
{ { A, B, C, D }, { 0+1*4, 1+2*4, 2+3*4, 3+4*4 }, { A, B, C, D } },
{ { A, B, C, D }, { 3, 2, 1, 0 }, { D, C, B, A } },
{ { A, B, C, D }, { 0, 3, 2, 1 }, { A, D, C, B } },
{ { A, B, C, D }, { 0, 2, 1, 3 }, { A, C, B, D } },
{ { W, X, Y, Z }, { 3, 1, 2, 0 }, { Z, X, Y, W } },
{ { W, X, Y, Z }, { 0, 0, 0, 0 }, { W, W, W, W } },
{ { W, X, Y, Z }, { 1, 2, 1, 2 }, { X, Y, X, Y } },
};
struct S2
{
V in1, in2;
VI mask;
V out;
};
struct S2 tests2[] = {
{ { A, B, C, D }, { W, X, Y, Z }, { 0, 1, 2, 3 }, { A, B, C, D } },
{ { A, B, C, D }, { W, X, Y, Z }, { 4, 5, 6, 7 }, { W, X, Y, Z } },
{ { A, B, C, D }, { W, X, Y, Z }, { 0, 4, 1, 5 }, { A, W, B, X } },
{ { A, B, C, D }, { W, X, Y, Z }, { 0, 7, 4, 3 }, { A, Z, W, D } },
{ { A, B, C, D }, { W, X, Y, Z }, { 0, 0, 0, 0 }, { A, A, A, A } },
{ { A, B, C, D }, { W, X, Y, Z }, { 7, 7, 7, 7 }, { Z, Z, Z, Z } },
};
#endif
gcc/testsuite/gcc.c-torture/execute/vshuf-8.inc 0 → 100644
/* Test fragment for vectors of 8 elements. */
#ifndef UNSUPPORTED
struct S
{
V in;
VI mask;
V out;
};
struct S tests[] = {
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ 0, 1, 2, 3, 4, 5, 6, 7 },
{ A1, B1, C1, D1, E1, F1, G1, H1 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ 0x10, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87 },
{ A1, B1, C1, D1, E1, F1, G1, H1 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ 7, 6, 5, 4, 3, 2, 1, 0 },
{ H1, G1, F1, E1, D1, C1, B1, A1 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ 7, 0, 5, 3, 2, 4, 1, 6 },
{ H1, A1, F1, D1, C1, E1, B1, G1 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ 0, 2, 1, 3, 4, 6, 5, 7 },
{ A1, C1, B1, D1, E1, G1, F1, H1 },
},
{
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 3, 1, 2, 0, 7, 5, 6, 4 },
{ D2, B2, C2, A2, H2, F2, G2, E2 },
},
{
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 0, 0, 0, 0 },
{ A2, A2, A2, A2, A2, A2, A2, A2 },
},
{
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 1, 6, 1, 6, 1, 6, 1, 6 },
{ B2, G2, B2, G2, B2, G2, B2, G2 },
}
};
struct S2
{
V in1, in2;
VI mask;
V out;
};
struct S2 tests2[] = {
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 0, 1, 2, 3, 4, 5, 6, 7 },
{ A1, B1, C1, D1, E1, F1, G1, H1 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 8, 9, 10, 11, 12, 13, 14, 15 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 0, 8, 1, 9, 2, 10, 3, 11 },
{ A1, A2, B1, B2, C1, C2, D1, D2 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 0, 15, 4, 11, 12, 3, 7, 8 },
{ A1, H2, E1, D2, E2, D1, H1, A2 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ A1, A1, A1, A1, A1, A1, A1, A1 },
},
{
{ A1, B1, C1, D1, E1, F1, G1, H1 },
{ A2, B2, C2, D2, E2, F2, G2, H2 },
{ 0x1e, 0x2e, 0x3e, 0x4e, 0x5e, 0x6e, 0x7e, 0x8e },
{ G2, G2, G2, G2, G2, G2, G2, G2 },
},
};
#endif
gcc/testsuite/gcc.c-torture/execute/vshuf-main.inc 0 → 100644
/* Driver fragment for __builtin_shuffle of any vector shape. */
extern void abort(void);
int main()
{
#ifndef UNSUPPORTED
int i;
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
{
V r = __builtin_shuffle(tests[i].in, tests[i].mask);
if (__builtin_memcmp(&r, &tests[i].out, sizeof(V)) != 0)
abort();
}
for (i = 0; i < sizeof(tests2)/sizeof(tests2[0]); ++i)
{
V r = __builtin_shuffle(tests2[i].in1, tests2[i].in2, tests2[i].mask);
if (__builtin_memcmp(&r, &tests2[i].out, sizeof(V)) != 0)
abort();
}
#endif
return 0;
}
gcc/testsuite/gcc.c-torture/execute/vshuf-v16qi.c 0 → 100644
typedef unsigned char V __attribute__((vector_size(16)));
typedef V VI;
#include "vshuf-16.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v2df.c 0 → 100644
#if __SIZEOF_DOUBLE__ == 8 && __SIZEOF_LONG_LONG__ == 8
typedef double V __attribute__((vector_size(16)));
typedef unsigned long long VI __attribute__((vector_size(16)));
#else
#define UNSUPPORTED
#endif
#define A 0.69314718055994530942
#define B 2.7182818284590452354
#define X 3.14159265358979323846
#define Y 1.41421356237309504880
#include "vshuf-2.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v2di.c 0 → 100644
#if __SIZEOF_LONG_LONG__ == 8
typedef unsigned long long V __attribute__((vector_size(16)));
typedef V VI;
#else
#define UNSUPPORTED
#endif
#define A 0x1112131415161718
#define B 0x2122232425262728
#define X 0xc1c2c3c4c5c6c7c8
#define Y 0xd1d2d3d4d5d6d7d8
#include "vshuf-2.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v2sf.c 0 → 100644
#if __SIZEOF_FLOAT__ == 4
typedef float V __attribute__((vector_size(8)));
# if __SIZEOF_INT__ == 4
typedef unsigned int VI __attribute__((vector_size(8)));
# elif __SIZEOF_LONG__ == 4
typedef unsigned long VI __attribute__((vector_size(8)));
# else
# define UNSUPPORTED
# endif
#else
# define UNSUPPORTED
#endif
#define A 0.69314718055994530942f
#define B 2.7182818284590452354f
#define X 3.14159265358979323846f
#define Y 1.41421356237309504880f
#include "vshuf-2.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v2si.c 0 → 100644
#if __SIZEOF_INT__ == 4
typedef unsigned int V __attribute__((vector_size(8)));
typedef V VI;
#elif __SIZEOF_LONG__ == 4
typedef unsigned long V __attribute__((vector_size(8)));
typedef V VI;
#else
#define UNSUPPORTED
#endif
#define A 0x11121314
#define B 0x21222324
#define X 0xd1d2d3d4
#define Y 0xe1e2e3e4
#include "vshuf-2.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v4df.c 0 → 100644
#if __SIZEOF_DOUBLE__ == 8 && __SIZEOF_LONG_LONG__ == 8
typedef double V __attribute__((vector_size(32)));
typedef unsigned long long VI __attribute__((vector_size(32)));
#else
#define UNSUPPORTED
#endif
#define A 0.69314718055994530942
#define B 2.7182818284590452354
#define C 2.30258509299404568402
#define D 1.4426950408889634074
#define W 0.31830988618379067154
#define X 3.14159265358979323846
#define Y 1.41421356237309504880
#define Z 0.70710678118654752440
#include "vshuf-4.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v4di.c 0 → 100644
#if __SIZEOF_LONG_LONG__ == 8
typedef unsigned long long V __attribute__((vector_size(32)));
typedef V VI;
#else
#define UNSUPPORTED
#endif
#define A 0x1112131415161718
#define B 0x2122232425262728
#define C 0x3132333435363738
#define D 0x4142434445464748
#define W 0xc1c2c3c4c5c6c7c8
#define X 0xd1d2d3d4d5d6d7d8
#define Y 0xe1e2e3e4e5e6e7e8
#define Z 0xf1f2f3f4f5f6f7f8
#include "vshuf-4.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v4hi.c 0 → 100644
typedef unsigned short V __attribute__((vector_size(8)));
typedef V VI;
#define A 0x1112
#define B 0x2122
#define C 0x3132
#define D 0x4142
#define W 0xc1c2
#define X 0xd1d2
#define Y 0xe1e2
#define Z 0xf1f2
#include "vshuf-4.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v4sf.c 0 → 100644
#if __SIZEOF_FLOAT__ == 4
typedef float V __attribute__((vector_size(16)));
# if __SIZEOF_INT__ == 4
typedef unsigned int VI __attribute__((vector_size(16)));
# elif __SIZEOF_LONG__ == 4
typedef unsigned long VI __attribute__((vector_size(16)));
# else
# define UNSUPPORTED
# endif
#else
# define UNSUPPORTED
#endif
#define A 0.69314718055994530942f
#define B 2.7182818284590452354f
#define C 2.30258509299404568402f
#define D 1.4426950408889634074f
#define W 0.31830988618379067154f
#define X 3.14159265358979323846f
#define Y 1.41421356237309504880f
#define Z 0.70710678118654752440f
#include "vshuf-4.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v4si.c 0 → 100644
#if __SIZEOF_INT__ == 4
typedef unsigned int V __attribute__((vector_size(16)));
typedef V VI;
#elif __SIZEOF_LONG__ == 4
typedef unsigned long V __attribute__((vector_size(16)));
typedef V VI;
#else
# define UNSUPPORTED
#endif
#define A 0x11121314
#define B 0x21222324
#define C 0x31323334
#define D 0x41424344
#define W 0xc1c2c3c4
#define X 0xd1d2d3d4
#define Y 0xe1e2e3e4
#define Z 0xf1f2f3f4
#include "vshuf-4.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v8hi.c 0 → 100644
typedef unsigned short V __attribute__((vector_size(16)));
typedef V VI;
#define A1 0x1112
#define B1 0x2122
#define C1 0x3132
#define D1 0x4142
#define E1 0x5152
#define F1 0x6162
#define G1 0x7172
#define H1 0x8182
#define A2 0x9192
#define B2 0xa1a2
#define C2 0xb1b2
#define D2 0xc1c2
#define E2 0xd1d2
#define F2 0xe1e2
#define G2 0xf1f2
#define H2 0x0102
#include "vshuf-8.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v8qi.c 0 → 100644
typedef unsigned char V __attribute__((vector_size(8)));
typedef V VI;
#define A1 0x11
#define B1 0x12
#define C1 0x13
#define D1 0x14
#define E1 0x15
#define F1 0x16
#define G1 0x17
#define H1 0x18
#define A2 0xf1
#define B2 0xf2
#define C2 0xf3
#define D2 0xf4
#define E2 0xf5
#define F2 0xf6
#define G2 0xf7
#define H2 0xf8
#include "vshuf-8.inc"
#include "vshuf-main.inc"
gcc/testsuite/gcc.c-torture/execute/vshuf-v8si.c 0 → 100644
#if __SIZEOF_INT__ == 4
typedef unsigned int V __attribute__((vector_size(32)));
typedef V VI;
#elif __SIZEOF_LONG__ == 4
typedef unsigned long V __attribute__((vector_size(32)));
typedef V VI;
#else
# define UNSUPPORTED
#endif
#define A1 0x11121314
#define B1 0x21222324
#define C1 0x31323334
#define D1 0x41424344
#define E1 0x51525354
#define F1 0x61626364
#define G1 0x71727374
#define H1 0x81828384
#define A2 0x91929394
#define B2 0xa1a2a3a4
#define C2 0xb1b2b3b4
#define D2 0xc1c2c3c4
#define E2 0xd1d2d3d4
#define F2 0xe1e2e3e4
#define G2 0xf1f2f3f4
#define H2 0x01020304
#include "vshuf-8.inc"
#include "vshuf-main.inc"
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment