Skip to content

R
riscv-gcc-1
Commit 5d06fbc1 by Bill Schmidt Committed by William Schmidt
Options

ops.c: Remove calls to vec_splat... 

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.

From-SVN: r215691
parent d03efd2a
Showing with 6 additions and 512 deletions
gcc/testsuite/ChangeLog
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.
2014-09-29 Chen Gang <gang.chen.5i5j@gmail.com>
* gcc.c-torture/compile/calls-void.c: New test.
......
gcc/testsuite/gcc.dg/vmx/ops.c
......@@ -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]);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment