* [PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c
@ 2014-09-29 17:27 Bill Schmidt
2014-09-29 17:44 ` David Edelsohn
0 siblings, 1 reply; 3+ messages in thread
From: Bill Schmidt @ 2014-09-29 17:27 UTC (permalink / raw)
To: gcc-patches; +Cc: dje.gcc
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 <wschmidt@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]);
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c
2014-09-29 17:27 [PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c Bill Schmidt
@ 2014-09-29 17:44 ` David Edelsohn
2014-10-06 2:06 ` Bill Schmidt
0 siblings, 1 reply; 3+ messages in thread
From: David Edelsohn @ 2014-09-29 17:44 UTC (permalink / raw)
To: Bill Schmidt; +Cc: GCC Patches
On Mon, Sep 29, 2014 at 1:27 PM, Bill Schmidt
<wschmidt@linux.vnet.ibm.com> wrote:
> 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 <wschmidt@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.
Okay.
Thanks, David
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c
2014-09-29 17:44 ` David Edelsohn
@ 2014-10-06 2:06 ` Bill Schmidt
0 siblings, 0 replies; 3+ messages in thread
From: Bill Schmidt @ 2014-10-06 2:06 UTC (permalink / raw)
To: David Edelsohn; +Cc: GCC Patches
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
On Mon, 2014-09-29 at 13:44 -0400, David Edelsohn wrote:
> On Mon, Sep 29, 2014 at 1:27 PM, Bill Schmidt
> <wschmidt@linux.vnet.ibm.com> wrote:
> > 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 <wschmidt@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.
>
> Okay.
>
> Thanks, David
>
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2014-10-06 2:06 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-09-29 17:27 [PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c Bill Schmidt
2014-09-29 17:44 ` David Edelsohn
2014-10-06 2:06 ` Bill Schmidt
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).