From patchwork Mon Sep 29 17:27:27 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bill Schmidt X-Patchwork-Id: 394523 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 8041E14009C for ; Tue, 30 Sep 2014 03:27:46 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:subject:from:to:cc:date:content-type:mime-version :content-transfer-encoding; q=dns; s=default; b=IUqjUzKDFy3yJ7rf 0TRU5qgtPdqocfoK4m/SLPFC+IiuiYYCzxIgC5ZkrneF8/HsSDmXZ07nJoAJ5OVp oDsI6DkJqBOeas0wAU4cahGJQcTt5kdZEssGlOnLZBcvP4I7t4TIlJEANdsgQ9/T DnK/C3h0K7UWGwmzj4JMe1KGx00= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:subject:from:to:cc:date:content-type:mime-version :content-transfer-encoding; s=default; bh=yBosFXTublAC1fiGBbUPlk P7zys=; b=LHLeAWNi7rA7fl2G/If1tA2DAeuh3hxDmN+FLIubwXGRwdLV0ERz5t NItw99XjvbeoxthZj0aqmXHvRo96H6yUNGlXZxAZymuET1e6H+a7Gs3UTWGwbtOy 4R9zbLm13BPPTr21SYcP+XA4gTjqI8e1WqSQ3f4CFDkII5lLUHQrU= 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-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@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 12:27:27 -0500 Mime-Version: 1.0 X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 14092917-6688-0000-0000-0000052CABFF X-IsSubscribed: yes 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]);