[PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c

[Bill Schmidt]

Hi,

While working on another patch, I observed that the test case
gcc.dg/vmx/ops.c contains numerous calls to vec_splat and friends for
which the second argument (the element selector) is out of range. At
best these calls are invalid; as it is, we generate insns that can cause
trouble during optimization. (In the case I saw, simplify-rtx tried to
reduce the splat of its input at compile time, but the out-of-range
element selector caused it to report a bad insn and abort.) This patch
removes all of the calls with out-of-range element selectors from the
test case.

Tested on powerpc64le-unknown-linux-gnu. Ok to commit?

Thanks,
Bill


2014-09-29 Bill Schmidt <***@vnet.linux.ibm.com>

* gcc.dg/vmx/ops.c: Remove calls to vec_splat, vec_vsplth,
vec_vspltw, and vec_vspltb for which the second argument is out of
range.


Index: gcc/testsuite/gcc.dg/vmx/ops.c
===================================================================
--- gcc/testsuite/gcc.dg/vmx/ops.c (revision 215683)
+++ gcc/testsuite/gcc.dg/vmx/ops.c (working copy)
@@ -337,32 +337,8 @@ void f2() {
*var_vec_b16++ = vec_splat(var_vec_b16[0], 5);
*var_vec_b16++ = vec_splat(var_vec_b16[0], 6);
*var_vec_b16++ = vec_splat(var_vec_b16[0], 7);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 8);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 9);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 10);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 11);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 12);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 13);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 14);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 15);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 16);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 17);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 18);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 19);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 20);
}
void f3() {
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 21);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 22);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 23);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 24);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 25);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 26);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 27);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 28);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 29);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 30);
- *var_vec_b16++ = vec_splat(var_vec_b16[0], 31);
*var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u16[1]);
*var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u32[1]);
*var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u8[1]);
@@ -393,30 +369,6 @@ void f3() {
*var_vec_b16++ = vec_vsplth(var_vec_b16[0], 5);
*var_vec_b16++ = vec_vsplth(var_vec_b16[0], 6);
*var_vec_b16++ = vec_vsplth(var_vec_b16[0], 7);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 8);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 9);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 10);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 11);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 12);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 13);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 14);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 15);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 16);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 17);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 18);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 19);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 20);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 21);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 22);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 23);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 24);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 25);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 26);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 27);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 28);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 29);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 30);
- *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 31);
*var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u16[1]);
*var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u32[1]);
*var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u8[1]);
@@ -451,36 +403,8 @@ void f3() {
*var_vec_b32++ = vec_splat(var_vec_b32[0], 1);
*var_vec_b32++ = vec_splat(var_vec_b32[0], 2);
*var_vec_b32++ = vec_splat(var_vec_b32[0], 3);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 4);
}
void f4() {
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 5);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 6);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 7);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 8);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 9);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 10);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 11);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 12);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 13);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 14);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 15);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 16);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 17);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 18);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 19);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 20);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 21);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 22);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 23);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 24);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 25);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 26);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 27);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 28);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 29);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 30);
- *var_vec_b32++ = vec_splat(var_vec_b32[0], 31);
*var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u16[1]);
*var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u32[1]);
*var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u8[1]);
@@ -509,34 +433,6 @@ void f4() {
*var_vec_b32++ = vec_vspltw(var_vec_b32[0], 1);
*var_vec_b32++ = vec_vspltw(var_vec_b32[0], 2);
*var_vec_b32++ = vec_vspltw(var_vec_b32[0], 3);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 4);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 5);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 6);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 7);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 8);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 9);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 10);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 11);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 12);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 13);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 14);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 15);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 16);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 17);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 18);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 19);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 20);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 21);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 22);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 23);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 24);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 25);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 26);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 27);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 28);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 29);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 30);
- *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 31);
*var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u16[1]);
*var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u32[1]);
*var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u8[1]);
@@ -583,22 +479,6 @@ void f5() {
*var_vec_b8++ = vec_splat(var_vec_b8[0], 13);
*var_vec_b8++ = vec_splat(var_vec_b8[0], 14);
*var_vec_b8++ = vec_splat(var_vec_b8[0], 15);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 16);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 17);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 18);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 19);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 20);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 21);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 22);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 23);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 24);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 25);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 26);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 27);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 28);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 29);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 30);
- *var_vec_b8++ = vec_splat(var_vec_b8[0], 31);
*var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u16[1]);
*var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u32[1]);
*var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u8[1]);
@@ -635,22 +515,6 @@ void f5() {
*var_vec_b8++ = vec_vspltb(var_vec_b8[0], 13);
*var_vec_b8++ = vec_vspltb(var_vec_b8[0], 14);
*var_vec_b8++ = vec_vspltb(var_vec_b8[0], 15);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 16);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 17);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 18);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 19);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 20);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 21);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 22);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 23);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 24);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 25);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 26);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 27);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 28);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 29);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 30);
- *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 31);
*var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u16[1]);
*var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u32[1]);
*var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u8[1]);
@@ -783,34 +647,6 @@ void f7() {
*var_vec_f32++ = vec_splat(var_vec_f32[0], 1);
*var_vec_f32++ = vec_splat(var_vec_f32[0], 2);
*var_vec_f32++ = vec_splat(var_vec_f32[0], 3);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 4);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 5);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 6);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 7);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 8);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 9);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 10);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 11);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 12);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 13);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 14);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 15);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 16);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 17);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 18);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 19);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 20);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 21);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 22);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 23);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 24);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 25);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 26);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 27);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 28);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 29);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 30);
- *var_vec_f32++ = vec_splat(var_vec_f32[0], 31);
*var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_s8[1]);
*var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_u8[1]);
*var_vec_f32++ = vec_sub(var_vec_f32[0], var_vec_f32[1]);
@@ -931,34 +767,6 @@ void f8() {
*var_vec_f32++ = vec_vspltw(var_vec_f32[0], 1);
*var_vec_f32++ = vec_vspltw(var_vec_f32[0], 2);
*var_vec_f32++ = vec_vspltw(var_vec_f32[0], 3);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 4);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 5);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 6);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 7);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 8);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 9);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 10);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 11);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 12);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 13);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 14);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 15);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 16);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 17);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 18);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 19);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 20);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 21);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 22);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 23);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 24);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 25);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 26);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 27);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 28);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 29);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 30);
- *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 31);
*var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_s8[1]);
*var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_u8[1]);
*var_vec_f32++ = vec_vsubfp(var_vec_f32[0], var_vec_f32[1]);
@@ -1007,30 +815,6 @@ void f9() {
*var_vec_p16++ = vec_splat(var_vec_p16[0], 5);
*var_vec_p16++ = vec_splat(var_vec_p16[0], 6);
*var_vec_p16++ = vec_splat(var_vec_p16[0], 7);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 8);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 9);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 10);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 11);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 12);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 13);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 14);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 15);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 16);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 17);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 18);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 19);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 20);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 21);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 22);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 23);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 24);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 25);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 26);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 27);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 28);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 29);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 30);
- *var_vec_p16++ = vec_splat(var_vec_p16[0], 31);
*var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u16[1]);
*var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u32[1]);
*var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u8[1]);
@@ -1071,30 +855,6 @@ void f10() {
*var_vec_p16++ = vec_vsplth(var_vec_p16[0], 5);
*var_vec_p16++ = vec_vsplth(var_vec_p16[0], 6);
*var_vec_p16++ = vec_vsplth(var_vec_p16[0], 7);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 8);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 9);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 10);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 11);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 12);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 13);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 14);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 15);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 16);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 17);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 18);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 19);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 20);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 21);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 22);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 23);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 24);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 25);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 26);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 27);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 28);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 29);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 30);
- *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 31);
*var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u16[1]);
*var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u32[1]);
*var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u8[1]);
@@ -1180,30 +940,6 @@ void f11() {
*var_vec_s16++ = vec_splat(var_vec_s16[0], 5);
*var_vec_s16++ = vec_splat(var_vec_s16[0], 6);
*var_vec_s16++ = vec_splat(var_vec_s16[0], 7);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 8);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 9);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 10);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 11);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 12);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 13);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 14);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 15);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 16);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 17);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 18);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 19);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 20);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 21);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 22);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 23);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 24);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 25);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 26);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 27);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 28);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 29);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 30);
- *var_vec_s16++ = vec_splat(var_vec_s16[0], 31);
*var_vec_s16++ = vec_splat_s16( 0);
*var_vec_s16++ = vec_splat_s16( 1);
*var_vec_s16++ = vec_splat_s16( 2);
@@ -1321,30 +1057,6 @@ void f12() {
*var_vec_s16++ = vec_vsplth(var_vec_s16[0], 5);
*var_vec_s16++ = vec_vsplth(var_vec_s16[0], 6);
*var_vec_s16++ = vec_vsplth(var_vec_s16[0], 7);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 8);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 9);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 10);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 11);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 12);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 13);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 14);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 15);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 16);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 17);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 18);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 19);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 20);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 21);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 22);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 23);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 24);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 25);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 26);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 27);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 28);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 29);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 30);
- *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 31);
*var_vec_s16++ = vec_vspltish( 0);
*var_vec_s16++ = vec_vspltish( 1);
*var_vec_s16++ = vec_vspltish( 2);
@@ -1505,34 +1217,6 @@ void f14() {
*var_vec_s32++ = vec_splat(var_vec_s32[0], 1);
*var_vec_s32++ = vec_splat(var_vec_s32[0], 2);
*var_vec_s32++ = vec_splat(var_vec_s32[0], 3);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 4);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 5);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 6);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 7);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 8);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 9);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 10);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 11);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 12);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 13);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 14);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 15);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 16);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 17);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 18);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 19);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 20);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 21);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 22);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 23);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 24);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 25);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 26);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 27);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 28);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 29);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 30);
- *var_vec_s32++ = vec_splat(var_vec_s32[0], 31);
*var_vec_s32++ = vec_splat_s32( 0);
*var_vec_s32++ = vec_splat_s32( 1);
*var_vec_s32++ = vec_splat_s32( 2);
@@ -1713,34 +1397,6 @@ void f16() {
*var_vec_s32++ = vec_vspltw(var_vec_s32[0], 1);
*var_vec_s32++ = vec_vspltw(var_vec_s32[0], 2);
*var_vec_s32++ = vec_vspltw(var_vec_s32[0], 3);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 4);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 5);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 6);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 7);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 8);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 9);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 10);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 11);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 12);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 13);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 14);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 15);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 16);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 17);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 18);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 19);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 20);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 21);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 22);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 23);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 24);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 25);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 26);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 27);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 28);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 29);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 30);
- *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 31);
*var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u16[1]);
*var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u32[1]);
*var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u8[1]);
@@ -1847,22 +1503,6 @@ void f17() {
*var_vec_s8++ = vec_splat(var_vec_s8[0], 13);
*var_vec_s8++ = vec_splat(var_vec_s8[0], 14);
*var_vec_s8++ = vec_splat(var_vec_s8[0], 15);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 16);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 17);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 18);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 19);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 20);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 21);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 22);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 23);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 24);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 25);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 26);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 27);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 28);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 29);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 30);
- *var_vec_s8++ = vec_splat(var_vec_s8[0], 31);
*var_vec_s8++ = vec_splat_s8( 0);
*var_vec_s8++ = vec_splat_s8( 1);
*var_vec_s8++ = vec_splat_s8( 2);
@@ -1981,22 +1621,6 @@ void f19() {
*var_vec_s8++ = vec_vspltb(var_vec_s8[0], 13);
*var_vec_s8++ = vec_vspltb(var_vec_s8[0], 14);
*var_vec_s8++ = vec_vspltb(var_vec_s8[0], 15);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 16);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 17);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 18);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 19);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 20);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 21);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 22);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 23);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 24);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 25);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 26);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 27);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 28);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 29);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 30);
- *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 31);
*var_vec_s8++ = vec_vspltisb( 0);
*var_vec_s8++ = vec_vspltisb( 1);
*var_vec_s8++ = vec_vspltisb( 2);
@@ -2126,30 +1750,6 @@ void f20() {
*var_vec_u16++ = vec_splat(var_vec_u16[0], 5);
*var_vec_u16++ = vec_splat(var_vec_u16[0], 6);
*var_vec_u16++ = vec_splat(var_vec_u16[0], 7);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 8);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 9);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 10);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 11);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 12);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 13);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 14);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 15);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 16);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 17);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 18);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 19);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 20);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 21);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 22);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 23);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 24);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 25);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 26);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 27);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 28);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 29);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 30);
- *var_vec_u16++ = vec_splat(var_vec_u16[0], 31);
*var_vec_u16++ = vec_splat_u16( 0);
*var_vec_u16++ = vec_splat_u16( 1);
*var_vec_u16++ = vec_splat_u16( 2);
@@ -2262,32 +1862,8 @@ void f21() {
*var_vec_u16++ = vec_vsplth(var_vec_u16[0], 5);
*var_vec_u16++ = vec_vsplth(var_vec_u16[0], 6);
*var_vec_u16++ = vec_vsplth(var_vec_u16[0], 7);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 8);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 9);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 10);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 11);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 12);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 13);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 14);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 15);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 16);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 17);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 18);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 19);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 20);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 21);
}
void f22() {
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 22);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 23);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 24);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 25);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 26);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 27);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 28);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 29);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 30);
- *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 31);
*var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u16[1]);
*var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u32[1]);
*var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u8[1]);
@@ -2412,34 +1988,6 @@ void f23() {
*var_vec_u32++ = vec_splat(var_vec_u32[0], 1);
*var_vec_u32++ = vec_splat(var_vec_u32[0], 2);
*var_vec_u32++ = vec_splat(var_vec_u32[0], 3);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 4);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 5);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 6);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 7);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 8);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 9);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 10);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 11);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 12);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 13);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 14);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 15);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 16);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 17);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 18);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 19);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 20);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 21);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 22);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 23);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 24);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 25);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 26);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 27);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 28);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 29);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 30);
- *var_vec_u32++ = vec_splat(var_vec_u32[0], 31);
*var_vec_u32++ = vec_splat_u32( 0);
*var_vec_u32++ = vec_splat_u32( 1);
*var_vec_u32++ = vec_splat_u32( 2);
@@ -2586,34 +2134,6 @@ void f25() {
*var_vec_u32++ = vec_vspltw(var_vec_u32[0], 1);
*var_vec_u32++ = vec_vspltw(var_vec_u32[0], 2);
*var_vec_u32++ = vec_vspltw(var_vec_u32[0], 3);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 4);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 5);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 6);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 7);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 8);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 9);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 10);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 11);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 12);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 13);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 14);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 15);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 16);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 17);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 18);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 19);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 20);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 21);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 22);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 23);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 24);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 25);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 26);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 27);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 28);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 29);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 30);
- *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 31);
*var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u16[1]);
*var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u32[1]);
*var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u8[1]);
@@ -2734,22 +2254,6 @@ void f26() {
*var_vec_u8++ = vec_splat(var_vec_u8[0], 13);
*var_vec_u8++ = vec_splat(var_vec_u8[0], 14);
*var_vec_u8++ = vec_splat(var_vec_u8[0], 15);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 16);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 17);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 18);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 19);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 20);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 21);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 22);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 23);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 24);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 25);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 26);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 27);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 28);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 29);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 30);
- *var_vec_u8++ = vec_splat(var_vec_u8[0], 31);
*var_vec_u8++ = vec_splat_u8( 0);
*var_vec_u8++ = vec_splat_u8( 1);
*var_vec_u8++ = vec_splat_u8( 2);
@@ -2867,24 +2371,8 @@ void f27() {
*var_vec_u8++ = vec_vspltb(var_vec_u8[0], 13);
*var_vec_u8++ = vec_vspltb(var_vec_u8[0], 14);
*var_vec_u8++ = vec_vspltb(var_vec_u8[0], 15);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 16);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 17);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 18);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 19);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 20);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 21);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 22);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 23);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 24);
}
void f28() {
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 25);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 26);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 27);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 28);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 29);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 30);
- *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 31);
*var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u16[1]);
*var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u32[1]);
*var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u8[1]);

[David Edelsohn]

On Mon, Sep 29, 2014 at 1:27 PM, Bill Schmidt

Post by Bill Schmidt
Hi,
While working on another patch, I observed that the test case
gcc.dg/vmx/ops.c contains numerous calls to vec_splat and friends for
which the second argument (the element selector) is out of range. At
best these calls are invalid; as it is, we generate insns that can cause
trouble during optimization. (In the case I saw, simplify-rtx tried to
reduce the splat of its input at compile time, but the out-of-range
element selector caused it to report a bad insn and abort.) This patch
removes all of the calls with out-of-range element selectors from the
test case.
Tested on powerpc64le-unknown-linux-gnu. Ok to commit?
Thanks,
Bill
* gcc.dg/vmx/ops.c: Remove calls to vec_splat, vec_vsplth,
vec_vspltw, and vec_vspltb for which the second argument is out of
range.

Okay.

Thanks, David

[Bill Schmidt]

By the way, just to follow up on a conversation we had offline: I did a
little poking, and found that the assembler objects if any of these
out-of-range arguments to vspltb, etc., survive the compiler:

/tmp/cctyppYZ.s: Assembler messages:
/tmp/cctyppYZ.s:25: Error: operand out of range (-1 is not between 0 and
3)

So if the test had been written with dg-do assemble instead of dg-do
compile, we would have found the issue long ago. Anyway, I was looking
into adding error checking for this in the compiler, but now that seems
redundant.

Thanks,
Bill

Post by David Edelsohn
On Mon, Sep 29, 2014 at 1:27 PM, Bill Schmidt

Post by Bill Schmidt
Hi,
While working on another patch, I observed that the test case
gcc.dg/vmx/ops.c contains numerous calls to vec_splat and friends for
which the second argument (the element selector) is out of range. At
best these calls are invalid; as it is, we generate insns that can cause
trouble during optimization. (In the case I saw, simplify-rtx tried to
reduce the splat of its input at compile time, but the out-of-range
element selector caused it to report a bad insn and abort.) This patch
removes all of the calls with out-of-range element selectors from the
test case.
Tested on powerpc64le-unknown-linux-gnu. Ok to commit?
Thanks,
Bill
* gcc.dg/vmx/ops.c: Remove calls to vec_splat, vec_vsplth,
vec_vspltw, and vec_vspltb for which the second argument is out of
range.

Okay.
Thanks, David