From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26670 invoked by alias); 29 Sep 2014 17:27:38 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 26654 invoked by uid 89); 29 Sep 2014 17:27:37 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.9 required=5.0 tests=AWL,BAYES_00,RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: e35.co.us.ibm.com Received: from e35.co.us.ibm.com (HELO e35.co.us.ibm.com) (32.97.110.153) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Mon, 29 Sep 2014 17:27:33 +0000 Received: from /spool/local by e35.co.us.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Mon, 29 Sep 2014 11:27:32 -0600 Received: from d03dlp03.boulder.ibm.com (9.17.202.179) by e35.co.us.ibm.com (192.168.1.135) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Mon, 29 Sep 2014 11:27:30 -0600 Received: from b03cxnp08025.gho.boulder.ibm.com (b03cxnp08025.gho.boulder.ibm.com [9.17.130.17]) by d03dlp03.boulder.ibm.com (Postfix) with ESMTP id 53B8419D803D for ; Mon, 29 Sep 2014 11:16:14 -0600 (MDT) Received: from d03av01.boulder.ibm.com (d03av01.boulder.ibm.com [9.17.195.167]) by b03cxnp08025.gho.boulder.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id s8THRTAV49414228 for ; Mon, 29 Sep 2014 19:27:29 +0200 Received: from d03av01.boulder.ibm.com (localhost [127.0.0.1]) by d03av01.boulder.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id s8THRT1d006705 for ; Mon, 29 Sep 2014 11:27:29 -0600 Received: from [9.80.9.80] ([9.80.9.80]) by d03av01.boulder.ibm.com (8.14.4/8.14.4/NCO v10.0 AVin) with ESMTP id s8THRRYY006543; Mon, 29 Sep 2014 11:27:27 -0600 Message-ID: <1412011647.2986.7.camel@gnopaine> Subject: [PATCH, rs6000] Remove splat calls with out-of-range arguments from gcc.dg/vmx/ops.c From: Bill Schmidt To: gcc-patches@gcc.gnu.org Cc: dje.gcc@gmail.com Date: Mon, 29 Sep 2014 17:27:00 -0000 Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 Content-Transfer-Encoding: 7bit X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 14092917-6688-0000-0000-0000052CABFF X-IsSubscribed: yes X-SW-Source: 2014-09/txt/msg02559.txt.bz2 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 * gcc.dg/vmx/ops.c: Remove calls to vec_splat, vec_vsplth, vec_vspltw, and vec_vspltb for which the second argument is out of range. Index: gcc/testsuite/gcc.dg/vmx/ops.c =================================================================== --- gcc/testsuite/gcc.dg/vmx/ops.c (revision 215683) +++ gcc/testsuite/gcc.dg/vmx/ops.c (working copy) @@ -337,32 +337,8 @@ void f2() { *var_vec_b16++ = vec_splat(var_vec_b16[0], 5); *var_vec_b16++ = vec_splat(var_vec_b16[0], 6); *var_vec_b16++ = vec_splat(var_vec_b16[0], 7); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 8); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 9); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 10); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 11); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 12); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 13); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 14); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 15); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 16); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 17); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 18); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 19); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 20); } void f3() { - *var_vec_b16++ = vec_splat(var_vec_b16[0], 21); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 22); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 23); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 24); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 25); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 26); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 27); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 28); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 29); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 30); - *var_vec_b16++ = vec_splat(var_vec_b16[0], 31); *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u16[1]); *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u32[1]); *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u8[1]); @@ -393,30 +369,6 @@ void f3() { *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 5); *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 6); *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 7); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 8); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 9); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 10); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 11); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 12); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 13); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 14); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 15); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 16); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 17); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 18); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 19); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 20); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 21); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 22); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 23); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 24); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 25); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 26); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 27); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 28); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 29); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 30); - *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 31); *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u16[1]); *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u32[1]); *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u8[1]); @@ -451,36 +403,8 @@ void f3() { *var_vec_b32++ = vec_splat(var_vec_b32[0], 1); *var_vec_b32++ = vec_splat(var_vec_b32[0], 2); *var_vec_b32++ = vec_splat(var_vec_b32[0], 3); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 4); } void f4() { - *var_vec_b32++ = vec_splat(var_vec_b32[0], 5); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 6); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 7); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 8); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 9); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 10); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 11); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 12); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 13); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 14); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 15); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 16); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 17); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 18); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 19); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 20); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 21); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 22); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 23); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 24); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 25); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 26); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 27); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 28); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 29); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 30); - *var_vec_b32++ = vec_splat(var_vec_b32[0], 31); *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u16[1]); *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u32[1]); *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u8[1]); @@ -509,34 +433,6 @@ void f4() { *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 1); *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 2); *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 3); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 4); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 5); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 6); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 7); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 8); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 9); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 10); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 11); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 12); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 13); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 14); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 15); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 16); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 17); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 18); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 19); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 20); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 21); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 22); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 23); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 24); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 25); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 26); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 27); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 28); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 29); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 30); - *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 31); *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u16[1]); *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u32[1]); *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u8[1]); @@ -583,22 +479,6 @@ void f5() { *var_vec_b8++ = vec_splat(var_vec_b8[0], 13); *var_vec_b8++ = vec_splat(var_vec_b8[0], 14); *var_vec_b8++ = vec_splat(var_vec_b8[0], 15); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 16); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 17); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 18); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 19); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 20); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 21); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 22); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 23); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 24); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 25); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 26); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 27); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 28); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 29); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 30); - *var_vec_b8++ = vec_splat(var_vec_b8[0], 31); *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u16[1]); *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u32[1]); *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u8[1]); @@ -635,22 +515,6 @@ void f5() { *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 13); *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 14); *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 15); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 16); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 17); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 18); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 19); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 20); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 21); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 22); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 23); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 24); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 25); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 26); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 27); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 28); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 29); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 30); - *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 31); *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u16[1]); *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u32[1]); *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u8[1]); @@ -783,34 +647,6 @@ void f7() { *var_vec_f32++ = vec_splat(var_vec_f32[0], 1); *var_vec_f32++ = vec_splat(var_vec_f32[0], 2); *var_vec_f32++ = vec_splat(var_vec_f32[0], 3); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 4); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 5); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 6); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 7); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 8); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 9); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 10); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 11); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 12); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 13); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 14); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 15); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 16); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 17); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 18); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 19); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 20); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 21); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 22); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 23); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 24); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 25); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 26); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 27); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 28); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 29); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 30); - *var_vec_f32++ = vec_splat(var_vec_f32[0], 31); *var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_s8[1]); *var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_u8[1]); *var_vec_f32++ = vec_sub(var_vec_f32[0], var_vec_f32[1]); @@ -931,34 +767,6 @@ void f8() { *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 1); *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 2); *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 3); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 4); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 5); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 6); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 7); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 8); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 9); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 10); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 11); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 12); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 13); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 14); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 15); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 16); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 17); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 18); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 19); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 20); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 21); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 22); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 23); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 24); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 25); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 26); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 27); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 28); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 29); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 30); - *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 31); *var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_s8[1]); *var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_u8[1]); *var_vec_f32++ = vec_vsubfp(var_vec_f32[0], var_vec_f32[1]); @@ -1007,30 +815,6 @@ void f9() { *var_vec_p16++ = vec_splat(var_vec_p16[0], 5); *var_vec_p16++ = vec_splat(var_vec_p16[0], 6); *var_vec_p16++ = vec_splat(var_vec_p16[0], 7); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 8); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 9); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 10); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 11); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 12); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 13); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 14); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 15); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 16); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 17); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 18); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 19); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 20); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 21); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 22); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 23); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 24); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 25); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 26); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 27); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 28); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 29); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 30); - *var_vec_p16++ = vec_splat(var_vec_p16[0], 31); *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u16[1]); *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u32[1]); *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u8[1]); @@ -1071,30 +855,6 @@ void f10() { *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 5); *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 6); *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 7); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 8); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 9); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 10); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 11); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 12); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 13); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 14); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 15); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 16); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 17); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 18); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 19); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 20); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 21); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 22); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 23); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 24); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 25); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 26); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 27); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 28); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 29); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 30); - *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 31); *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u16[1]); *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u32[1]); *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u8[1]); @@ -1180,30 +940,6 @@ void f11() { *var_vec_s16++ = vec_splat(var_vec_s16[0], 5); *var_vec_s16++ = vec_splat(var_vec_s16[0], 6); *var_vec_s16++ = vec_splat(var_vec_s16[0], 7); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 8); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 9); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 10); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 11); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 12); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 13); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 14); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 15); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 16); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 17); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 18); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 19); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 20); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 21); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 22); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 23); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 24); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 25); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 26); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 27); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 28); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 29); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 30); - *var_vec_s16++ = vec_splat(var_vec_s16[0], 31); *var_vec_s16++ = vec_splat_s16( 0); *var_vec_s16++ = vec_splat_s16( 1); *var_vec_s16++ = vec_splat_s16( 2); @@ -1321,30 +1057,6 @@ void f12() { *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 5); *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 6); *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 7); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 8); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 9); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 10); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 11); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 12); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 13); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 14); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 15); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 16); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 17); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 18); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 19); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 20); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 21); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 22); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 23); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 24); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 25); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 26); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 27); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 28); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 29); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 30); - *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 31); *var_vec_s16++ = vec_vspltish( 0); *var_vec_s16++ = vec_vspltish( 1); *var_vec_s16++ = vec_vspltish( 2); @@ -1505,34 +1217,6 @@ void f14() { *var_vec_s32++ = vec_splat(var_vec_s32[0], 1); *var_vec_s32++ = vec_splat(var_vec_s32[0], 2); *var_vec_s32++ = vec_splat(var_vec_s32[0], 3); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 4); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 5); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 6); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 7); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 8); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 9); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 10); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 11); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 12); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 13); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 14); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 15); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 16); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 17); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 18); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 19); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 20); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 21); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 22); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 23); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 24); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 25); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 26); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 27); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 28); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 29); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 30); - *var_vec_s32++ = vec_splat(var_vec_s32[0], 31); *var_vec_s32++ = vec_splat_s32( 0); *var_vec_s32++ = vec_splat_s32( 1); *var_vec_s32++ = vec_splat_s32( 2); @@ -1713,34 +1397,6 @@ void f16() { *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 1); *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 2); *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 3); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 4); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 5); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 6); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 7); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 8); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 9); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 10); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 11); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 12); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 13); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 14); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 15); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 16); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 17); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 18); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 19); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 20); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 21); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 22); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 23); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 24); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 25); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 26); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 27); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 28); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 29); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 30); - *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 31); *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u16[1]); *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u32[1]); *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u8[1]); @@ -1847,22 +1503,6 @@ void f17() { *var_vec_s8++ = vec_splat(var_vec_s8[0], 13); *var_vec_s8++ = vec_splat(var_vec_s8[0], 14); *var_vec_s8++ = vec_splat(var_vec_s8[0], 15); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 16); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 17); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 18); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 19); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 20); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 21); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 22); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 23); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 24); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 25); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 26); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 27); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 28); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 29); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 30); - *var_vec_s8++ = vec_splat(var_vec_s8[0], 31); *var_vec_s8++ = vec_splat_s8( 0); *var_vec_s8++ = vec_splat_s8( 1); *var_vec_s8++ = vec_splat_s8( 2); @@ -1981,22 +1621,6 @@ void f19() { *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 13); *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 14); *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 15); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 16); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 17); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 18); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 19); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 20); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 21); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 22); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 23); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 24); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 25); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 26); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 27); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 28); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 29); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 30); - *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 31); *var_vec_s8++ = vec_vspltisb( 0); *var_vec_s8++ = vec_vspltisb( 1); *var_vec_s8++ = vec_vspltisb( 2); @@ -2126,30 +1750,6 @@ void f20() { *var_vec_u16++ = vec_splat(var_vec_u16[0], 5); *var_vec_u16++ = vec_splat(var_vec_u16[0], 6); *var_vec_u16++ = vec_splat(var_vec_u16[0], 7); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 8); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 9); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 10); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 11); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 12); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 13); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 14); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 15); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 16); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 17); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 18); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 19); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 20); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 21); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 22); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 23); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 24); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 25); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 26); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 27); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 28); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 29); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 30); - *var_vec_u16++ = vec_splat(var_vec_u16[0], 31); *var_vec_u16++ = vec_splat_u16( 0); *var_vec_u16++ = vec_splat_u16( 1); *var_vec_u16++ = vec_splat_u16( 2); @@ -2262,32 +1862,8 @@ void f21() { *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 5); *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 6); *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 7); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 8); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 9); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 10); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 11); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 12); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 13); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 14); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 15); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 16); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 17); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 18); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 19); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 20); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 21); } void f22() { - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 22); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 23); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 24); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 25); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 26); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 27); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 28); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 29); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 30); - *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 31); *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u16[1]); *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u32[1]); *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u8[1]); @@ -2412,34 +1988,6 @@ void f23() { *var_vec_u32++ = vec_splat(var_vec_u32[0], 1); *var_vec_u32++ = vec_splat(var_vec_u32[0], 2); *var_vec_u32++ = vec_splat(var_vec_u32[0], 3); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 4); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 5); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 6); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 7); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 8); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 9); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 10); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 11); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 12); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 13); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 14); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 15); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 16); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 17); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 18); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 19); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 20); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 21); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 22); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 23); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 24); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 25); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 26); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 27); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 28); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 29); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 30); - *var_vec_u32++ = vec_splat(var_vec_u32[0], 31); *var_vec_u32++ = vec_splat_u32( 0); *var_vec_u32++ = vec_splat_u32( 1); *var_vec_u32++ = vec_splat_u32( 2); @@ -2586,34 +2134,6 @@ void f25() { *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 1); *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 2); *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 3); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 4); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 5); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 6); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 7); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 8); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 9); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 10); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 11); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 12); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 13); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 14); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 15); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 16); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 17); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 18); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 19); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 20); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 21); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 22); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 23); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 24); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 25); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 26); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 27); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 28); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 29); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 30); - *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 31); *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u16[1]); *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u32[1]); *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u8[1]); @@ -2734,22 +2254,6 @@ void f26() { *var_vec_u8++ = vec_splat(var_vec_u8[0], 13); *var_vec_u8++ = vec_splat(var_vec_u8[0], 14); *var_vec_u8++ = vec_splat(var_vec_u8[0], 15); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 16); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 17); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 18); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 19); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 20); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 21); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 22); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 23); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 24); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 25); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 26); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 27); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 28); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 29); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 30); - *var_vec_u8++ = vec_splat(var_vec_u8[0], 31); *var_vec_u8++ = vec_splat_u8( 0); *var_vec_u8++ = vec_splat_u8( 1); *var_vec_u8++ = vec_splat_u8( 2); @@ -2867,24 +2371,8 @@ void f27() { *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 13); *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 14); *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 15); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 16); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 17); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 18); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 19); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 20); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 21); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 22); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 23); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 24); } void f28() { - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 25); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 26); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 27); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 28); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 29); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 30); - *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 31); *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u16[1]); *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u32[1]); *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u8[1]);