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
This commit is contained in:
Bill Schmidt
William Schmidt
parent
d03efd2a58
commit
5d06fbc109
|
|
@ -1,3 +1,9 @@
|
|||
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.
|
||||
|
|
|
|||
|
|
@ -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]);
|
||||
|
|
|
|||
Loading…
Reference in New Issue