diff mbox

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

Message ID 1412011647.2986.7.camel@gnopaine
State New
Headers show

Commit Message

Bill Schmidt Sept. 29, 2014, 5:27 p.m. UTC 
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.

Comments

David Edelsohn Sept. 29, 2014, 5:44 p.m. UTC | #1 
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
Bill Schmidt Oct. 6, 2014, 2:06 a.m. UTC | #2 
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
>
diff mbox

Patch

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]);