From patchwork Tue May 12 20:30:57 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Christophe Lyon X-Patchwork-Id: 48413 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-wi0-f197.google.com (mail-wi0-f197.google.com [209.85.212.197]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id DDD8B2121F for ; Tue, 12 May 2015 20:35:27 +0000 (UTC) Received: by wizk4 with SMTP id k4sf5783484wiz.2 for ; Tue, 12 May 2015 13:35:27 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:delivered-to:mailing-list :precedence:list-id:list-unsubscribe:list-archive:list-post :list-help:sender:delivered-to:from:to:subject:date:message-id :in-reply-to:references:x-original-sender :x-original-authentication-results; bh=ACQC0SyqCF/rKW/xsOFYYgajL/AcY7uuBfIBm62r9I4=; b=IzvswAjUTFwua6aKT9QA0S+wWOgJReTf1Ws6Yb+ZAtaciKdTmeXhvTEp6aQDjJrKUf IJ63Vbjandsamedy0n/jYNeHkYpfzLc5jZIRimsNSX8DMDsDQTxR+lUXGsSXcTj9Wun+ 4X8rjvu4UHxma5SsWXFftEHgdKkXBQ7dOlva3uNn+Plo/cUMLNdVCZWQUD8ErKQQFHS4 /X5uVAlQA7VsJyQZfj/rEKZ1wml7CwBDjT8heSImYauRskMcNurTr+hxV9IS0zryXLRW ifQFD2TJ3skPgAqy2WxrnFjf4xmvY/1Jszu+an/XvEsAgV3+hBfPE2DOb6XXXMCrp+AE UyuQ== X-Gm-Message-State: ALoCoQl/DQlgg0OUE5ig8ozLckjvgvs9+2Fv8+93n+GKjy0Ga1BI4E9GgkD5/7w0wRDDPZGGkiT1 X-Received: by 10.112.29.39 with SMTP id g7mr11733477lbh.1.1431462926985; Tue, 12 May 2015 13:35:26 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.153.5.42 with SMTP id cj10ls93084lad.51.gmail; Tue, 12 May 2015 13:35:26 -0700 (PDT) X-Received: by 10.112.126.162 with SMTP id mz2mr13080989lbb.97.1431462926753; Tue, 12 May 2015 13:35:26 -0700 (PDT) Received: from mail-lb0-x231.google.com (mail-lb0-x231.google.com. [2a00:1450:4010:c04::231]) by mx.google.com with ESMTPS id zk9si11022927lbb.58.2015.05.12.13.35.26 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 12 May 2015 13:35:26 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c04::231 as permitted sender) client-ip=2a00:1450:4010:c04::231; Received: by lbbqq2 with SMTP id qq2so14884583lbb.3 for ; Tue, 12 May 2015 13:35:26 -0700 (PDT) X-Received: by 10.152.27.98 with SMTP id s2mr13503815lag.106.1431462926591; Tue, 12 May 2015 13:35:26 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.108.230 with SMTP id hn6csp137926lbb; Tue, 12 May 2015 13:35:24 -0700 (PDT) X-Received: by 10.70.102.132 with SMTP id fo4mr31294276pdb.31.1431462923867; Tue, 12 May 2015 13:35:23 -0700 (PDT) Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id z8si24013920pas.64.2015.05.12.13.35.22 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 12 May 2015 13:35:23 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-return-397721-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Received: (qmail 76997 invoked by alias); 12 May 2015 20:31:30 -0000 Mailing-List: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org Precedence: list 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 76871 invoked by uid 89); 12 May 2015 20:31:30 -0000 X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.6 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-wg0-f51.google.com Received: from mail-wg0-f51.google.com (HELO mail-wg0-f51.google.com) (74.125.82.51) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Tue, 12 May 2015 20:31:23 +0000 Received: by wggj6 with SMTP id j6so22696418wgg.3 for ; Tue, 12 May 2015 13:31:20 -0700 (PDT) X-Received: by 10.194.6.102 with SMTP id z6mr34233511wjz.121.1431462680553; Tue, 12 May 2015 13:31:20 -0700 (PDT) Received: from babel.clyon.hd.free.fr (vig38-2-82-225-222-175.fbx.proxad.net. [82.225.222.175]) by mx.google.com with ESMTPSA id u9sm24921095wju.44.2015.05.12.13.31.19 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 12 May 2015 13:31:19 -0700 (PDT) From: Christophe Lyon To: gcc-patches@gcc.gnu.org Subject: [Patch ARM-AArch64/testsuite Neon intrinsics 09/13] Add vqshl tests. Date: Tue, 12 May 2015 22:30:57 +0200 Message-Id: <1431462661-27247-10-git-send-email-christophe.lyon@linaro.org> In-Reply-To: <1431462661-27247-1-git-send-email-christophe.lyon@linaro.org> References: <1431462661-27247-1-git-send-email-christophe.lyon@linaro.org> X-IsSubscribed: yes X-Original-Sender: christophe.lyon@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c04::231 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org; dkim=pass header.i=@gcc.gnu.org X-Google-Group-Id: 836684582541 diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vqshl.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vqshl.c new file mode 100644 index 0000000..f5a3084 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vqshl.c @@ -0,0 +1,829 @@ +#include +#include "arm-neon-ref.h" +#include "compute-ref-data.h" + +/* Expected values of cumulative_saturation flag with input=0. */ +int VECT_VAR(expected_cumulative_sat_0,int,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_0,int,64,2) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_0,uint,64,2) = 0; + +/* Expected results with input=0. */ +VECT_VAR_DECL(expected_0,int,8,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,int,16,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,int,32,2) [] = { 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,int,64,1) [] = { 0x0 }; +VECT_VAR_DECL(expected_0,uint,8,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,16,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,32,2) [] = { 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,64,1) [] = { 0x0 }; +VECT_VAR_DECL(expected_0,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,int,64,2) [] = { 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,8,16) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,16,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,32,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0,uint,64,2) [] = { 0x0, 0x0 }; + +/* Expected values of cumulative_saturation flag with input=0 and + negative shift amount. */ +int VECT_VAR(expected_cumulative_sat_0_neg,int,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,int,64,2) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_0_neg,uint,64,2) = 0; + +/* Expected results with input=0 and negative shift amount. */ +VECT_VAR_DECL(expected_0_neg,int,8,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,16,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,32,2) [] = { 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,64,1) [] = { 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,8,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,16,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,32,2) [] = { 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,64,1) [] = { 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,int,64,2) [] = { 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,8,16) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,16,8) [] = { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,32,4) [] = { 0x0, 0x0, 0x0, 0x0 }; +VECT_VAR_DECL(expected_0_neg,uint,64,2) [] = { 0x0, 0x0 }; + +/* Expected values of cumulative_saturation flag. */ +int VECT_VAR(expected_cumulative_sat,int,8,8) = 0; +int VECT_VAR(expected_cumulative_sat,int,16,4) = 0; +int VECT_VAR(expected_cumulative_sat,int,32,2) = 0; +int VECT_VAR(expected_cumulative_sat,int,64,1) = 0; +int VECT_VAR(expected_cumulative_sat,uint,8,8) = 1; +int VECT_VAR(expected_cumulative_sat,uint,16,4) = 1; +int VECT_VAR(expected_cumulative_sat,uint,32,2) = 1; +int VECT_VAR(expected_cumulative_sat,uint,64,1) = 0; +int VECT_VAR(expected_cumulative_sat,int,8,16) = 1; +int VECT_VAR(expected_cumulative_sat,int,16,8) = 1; +int VECT_VAR(expected_cumulative_sat,int,32,4) = 1; +int VECT_VAR(expected_cumulative_sat,int,64,2) = 1; +int VECT_VAR(expected_cumulative_sat,uint,8,16) = 1; +int VECT_VAR(expected_cumulative_sat,uint,16,8) = 1; +int VECT_VAR(expected_cumulative_sat,uint,32,4) = 1; +int VECT_VAR(expected_cumulative_sat,uint,64,2) = 1; + +/* Expected results. */ +VECT_VAR_DECL(expected,int,8,8) [] = { 0xe0, 0xe2, 0xe4, 0xe6, + 0xe8, 0xea, 0xec, 0xee }; +VECT_VAR_DECL(expected,int,16,4) [] = { 0xff80, 0xff88, 0xff90, 0xff98 }; +VECT_VAR_DECL(expected,int,32,2) [] = { 0xfffff000, 0xfffff100 }; +VECT_VAR_DECL(expected,int,64,1) [] = { 0xfffffffffffffffe }; +VECT_VAR_DECL(expected,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected,uint,16,4) [] = { 0xffff, 0xffff, 0xffff, 0xffff }; +VECT_VAR_DECL(expected,uint,32,2) [] = { 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected,uint,64,1) [] = { 0x1ffffffffffffffe }; +VECT_VAR_DECL(expected,int,8,16) [] = { 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80 }; +VECT_VAR_DECL(expected,int,16,8) [] = { 0x8000, 0x8000, 0x8000, 0x8000, + 0x8000, 0x8000, 0x8000, 0x8000 }; +VECT_VAR_DECL(expected,int,32,4) [] = { 0x80000000, 0x80000000, + 0x80000000, 0x80000000 }; +VECT_VAR_DECL(expected,int,64,2) [] = { 0x8000000000000000, + 0x8000000000000000 }; +VECT_VAR_DECL(expected,uint,8,16) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected,uint,16,8) [] = { 0xffff, 0xffff, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff }; +VECT_VAR_DECL(expected,uint,32,4) [] = { 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected,uint,64,2) [] = { 0xffffffffffffffff, + 0xffffffffffffffff }; + +/* Expected values of cumulative_sat_saturation flag with negative shift + amount. */ +int VECT_VAR(expected_cumulative_sat_neg,int,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_neg,int,64,2) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_neg,uint,64,2) = 0; + +/* Expected results with negative shift amount. */ +VECT_VAR_DECL(expected_neg,int,8,8) [] = { 0xf8, 0xf8, 0xf9, 0xf9, + 0xfa, 0xfa, 0xfb, 0xfb }; +VECT_VAR_DECL(expected_neg,int,16,4) [] = { 0xfffc, 0xfffc, 0xfffc, 0xfffc }; +VECT_VAR_DECL(expected_neg,int,32,2) [] = { 0xfffffffe, 0xfffffffe }; +VECT_VAR_DECL(expected_neg,int,64,1) [] = { 0xffffffffffffffff }; +VECT_VAR_DECL(expected_neg,uint,8,8) [] = { 0x78, 0x78, 0x79, 0x79, + 0x7a, 0x7a, 0x7b, 0x7b }; +VECT_VAR_DECL(expected_neg,uint,16,4) [] = { 0x3ffc, 0x3ffc, 0x3ffc, 0x3ffc }; +VECT_VAR_DECL(expected_neg,uint,32,2) [] = { 0x1ffffffe, 0x1ffffffe }; +VECT_VAR_DECL(expected_neg,uint,64,1) [] = { 0xfffffffffffffff }; +VECT_VAR_DECL(expected_neg,int,8,16) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected_neg,int,16,8) [] = { 0xffff, 0xffff, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff }; +VECT_VAR_DECL(expected_neg,int,32,4) [] = { 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected_neg,int,64,2) [] = { 0xffffffffffffffff, + 0xffffffffffffffff }; +VECT_VAR_DECL(expected_neg,uint,8,16) [] = { 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1 }; +VECT_VAR_DECL(expected_neg,uint,16,8) [] = { 0x1f, 0x1f, 0x1f, 0x1f, + 0x1f, 0x1f, 0x1f, 0x1f }; +VECT_VAR_DECL(expected_neg,uint,32,4) [] = { 0x7ffff, 0x7ffff, + 0x7ffff, 0x7ffff }; +VECT_VAR_DECL(expected_neg,uint,64,2) [] = { 0xfffffffffff, 0xfffffffffff }; + +/* Expected values of cumulative_sat_saturation flag with negative + input and large shift amount. */ +int VECT_VAR(expected_cumulative_sat_neg_large,int,8,8) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,16,4) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,32,2) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,64,1) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,8,8) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,16,4) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,32,2) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,64,1) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,8,16) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,16,8) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,32,4) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,int,64,2) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,8,16) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,16,8) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,32,4) = 1; +int VECT_VAR(expected_cumulative_sat_neg_large,uint,64,2) = 1; + +/* Expected results with negative input and large shift amount. */ +VECT_VAR_DECL(expected_neg_large,int,8,8) [] = { 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80 }; +VECT_VAR_DECL(expected_neg_large,int,16,4) [] = { 0x8000, 0x8000, + 0x8000, 0x8000 }; +VECT_VAR_DECL(expected_neg_large,int,32,2) [] = { 0x80000000, 0x80000000 }; +VECT_VAR_DECL(expected_neg_large,int,64,1) [] = { 0x8000000000000000 }; +VECT_VAR_DECL(expected_neg_large,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected_neg_large,uint,16,4) [] = { 0xffff, 0xffff, + 0xffff, 0xffff }; +VECT_VAR_DECL(expected_neg_large,uint,32,2) [] = { 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected_neg_large,uint,64,1) [] = { 0xffffffffffffffff }; +VECT_VAR_DECL(expected_neg_large,int,8,16) [] = { 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80 }; +VECT_VAR_DECL(expected_neg_large,int,16,8) [] = { 0x8000, 0x8000, + 0x8000, 0x8000, + 0x8000, 0x8000, + 0x8000, 0x8000 }; +VECT_VAR_DECL(expected_neg_large,int,32,4) [] = { 0x80000000, 0x80000000, + 0x80000000, 0x80000000 }; +VECT_VAR_DECL(expected_neg_large,int,64,2) [] = { 0x8000000000000000, + 0x8000000000000000 }; +VECT_VAR_DECL(expected_neg_large,uint,8,16) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected_neg_large,uint,16,8) [] = { 0xffff, 0xffff, + 0xffff, 0xffff, + 0xffff, 0xffff, + 0xffff, 0xffff }; +VECT_VAR_DECL(expected_neg_large,uint,32,4) [] = { 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected_neg_large,uint,64,2) [] = { 0xffffffffffffffff, + 0xffffffffffffffff }; + +/* Expected values of cumulative_sat_saturation flag with max input + and shift by -1. */ +int VECT_VAR(expected_cumulative_sat_max_minus1,int,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,8,8) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,16,4) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,32,2) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,64,1) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,int,64,2) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,8,16) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,16,8) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,32,4) = 0; +int VECT_VAR(expected_cumulative_sat_max_minus1,uint,64,2) = 0; + +/* Expected results with max input and shift by -1. */ +VECT_VAR_DECL(expected_max_minus1,int,8,8) [] = { 0x3f, 0x3f, 0x3f, 0x3f, + 0x3f, 0x3f, 0x3f, 0x3f }; +VECT_VAR_DECL(expected_max_minus1,int,16,4) [] = { 0x3fff, 0x3fff, + 0x3fff, 0x3fff }; +VECT_VAR_DECL(expected_max_minus1,int,32,2) [] = { 0x3fffffff, 0x3fffffff }; +VECT_VAR_DECL(expected_max_minus1,int,64,1) [] = { 0x3fffffffffffffff }; +VECT_VAR_DECL(expected_max_minus1,uint,8,8) [] = { 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f }; +VECT_VAR_DECL(expected_max_minus1,uint,16,4) [] = { 0x7fff, 0x7fff, + 0x7fff, 0x7fff }; +VECT_VAR_DECL(expected_max_minus1,uint,32,2) [] = { 0x7fffffff, 0x7fffffff }; +VECT_VAR_DECL(expected_max_minus1,uint,64,1) [] = { 0x7fffffffffffffff }; +VECT_VAR_DECL(expected_max_minus1,int,8,16) [] = { 0x3f, 0x3f, 0x3f, 0x3f, + 0x3f, 0x3f, 0x3f, 0x3f, + 0x3f, 0x3f, 0x3f, 0x3f, + 0x3f, 0x3f, 0x3f, 0x3f }; +VECT_VAR_DECL(expected_max_minus1,int,16,8) [] = { 0x3fff, 0x3fff, + 0x3fff, 0x3fff, + 0x3fff, 0x3fff, + 0x3fff, 0x3fff }; +VECT_VAR_DECL(expected_max_minus1,int,32,4) [] = { 0x3fffffff, 0x3fffffff, + 0x3fffffff, 0x3fffffff }; +VECT_VAR_DECL(expected_max_minus1,int,64,2) [] = { 0x3fffffffffffffff, + 0x3fffffffffffffff }; +VECT_VAR_DECL(expected_max_minus1,uint,8,16) [] = { 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f }; +VECT_VAR_DECL(expected_max_minus1,uint,16,8) [] = { 0x7fff, 0x7fff, + 0x7fff, 0x7fff, + 0x7fff, 0x7fff, + 0x7fff, 0x7fff }; +VECT_VAR_DECL(expected_max_minus1,uint,32,4) [] = { 0x7fffffff, 0x7fffffff, + 0x7fffffff, 0x7fffffff }; +VECT_VAR_DECL(expected_max_minus1,uint,64,2) [] = { 0x7fffffffffffffff, + 0x7fffffffffffffff }; + +/* Expected values of cumulative_sat_saturation flag with max input + and large shift amount. */ +int VECT_VAR(expected_cumulative_sat_max_large,int,8,8) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,16,4) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,32,2) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,64,1) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,8,8) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,16,4) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,32,2) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,64,1) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,8,16) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,16,8) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,32,4) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,int,64,2) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,8,16) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,16,8) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,32,4) = 1; +int VECT_VAR(expected_cumulative_sat_max_large,uint,64,2) = 1; + +/* Expected results with max input and large shift amount. */ +VECT_VAR_DECL(expected_max_large,int,8,8) [] = { 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f }; +VECT_VAR_DECL(expected_max_large,int,16,4) [] = { 0x7fff, 0x7fff, + 0x7fff, 0x7fff }; +VECT_VAR_DECL(expected_max_large,int,32,2) [] = { 0x7fffffff, 0x7fffffff }; +VECT_VAR_DECL(expected_max_large,int,64,1) [] = { 0x7fffffffffffffff }; +VECT_VAR_DECL(expected_max_large,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected_max_large,uint,16,4) [] = { 0xffff, 0xffff, + 0xffff, 0xffff }; +VECT_VAR_DECL(expected_max_large,uint,32,2) [] = { 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected_max_large,uint,64,1) [] = { 0xffffffffffffffff }; +VECT_VAR_DECL(expected_max_large,int,8,16) [] = { 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f }; +VECT_VAR_DECL(expected_max_large,int,16,8) [] = { 0x7fff, 0x7fff, + 0x7fff, 0x7fff, + 0x7fff, 0x7fff, + 0x7fff, 0x7fff }; +VECT_VAR_DECL(expected_max_large,int,32,4) [] = { 0x7fffffff, 0x7fffffff, + 0x7fffffff, 0x7fffffff }; +VECT_VAR_DECL(expected_max_large,int,64,2) [] = { 0x7fffffffffffffff, + 0x7fffffffffffffff }; +VECT_VAR_DECL(expected_max_large,uint,8,16) [] = { 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff }; +VECT_VAR_DECL(expected_max_large,uint,16,8) [] = { 0xffff, 0xffff, + 0xffff, 0xffff, + 0xffff, 0xffff, + 0xffff, 0xffff }; +VECT_VAR_DECL(expected_max_large,uint,32,4) [] = { 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff }; +VECT_VAR_DECL(expected_max_large,uint,64,2) [] = { 0xffffffffffffffff, + 0xffffffffffffffff }; + +/* Expected values of cumulative_sat_saturation flag with saturation + on 64-bits values. */ +int VECT_VAR(expected_cumulative_sat_64,int,64,1) = 1; +int VECT_VAR(expected_cumulative_sat_64,int,64,2) = 1; + +/* Expected results with saturation on 64-bits values.. */ +VECT_VAR_DECL(expected_64,int,64,1) [] = { 0x8000000000000000 }; +VECT_VAR_DECL(expected_64,int,64,2) [] = { 0x7fffffffffffffff, + 0x7fffffffffffffff }; + +#define INSN vqshl +#define TEST_MSG "VQSHL/VQSHLQ" + +#define FNNAME1(NAME) void exec_ ## NAME (void) +#define FNNAME(NAME) FNNAME1(NAME) + +FNNAME (INSN) +{ + /* Basic test: v3=vqshl(v1,v2), then store the result. */ +#define TEST_VQSHL2(INSN, T3, Q, T1, T2, W, N, EXPECTED_CUMULATIVE_SAT, CMT) \ + Set_Neon_Cumulative_Sat(0, VECT_VAR(vector_res, T1, W, N)); \ + VECT_VAR(vector_res, T1, W, N) = \ + INSN##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \ + VECT_VAR(vector_shift, T3, W, N)); \ + vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), \ + VECT_VAR(vector_res, T1, W, N)); \ + CHECK_CUMULATIVE_SAT(TEST_MSG, T1, W, N, EXPECTED_CUMULATIVE_SAT, CMT) + + /* Two auxliary macros are necessary to expand INSN */ +#define TEST_VQSHL1(INSN, T3, Q, T1, T2, W, N, EXPECTED_CUMULATIVE_SAT, CMT) \ + TEST_VQSHL2(INSN, T3, Q, T1, T2, W, N, EXPECTED_CUMULATIVE_SAT, CMT) + +#define TEST_VQSHL(T3, Q, T1, T2, W, N, EXPECTED_CUMULATIVE_SAT, CMT) \ + TEST_VQSHL1(INSN, T3, Q, T1, T2, W, N, EXPECTED_CUMULATIVE_SAT, CMT) + + + DECL_VARIABLE_ALL_VARIANTS(vector); + DECL_VARIABLE_ALL_VARIANTS(vector_res); + + DECL_VARIABLE_SIGNED_VARIANTS(vector_shift); + + clean_results (); + + /* Fill input vector with 0, to check saturation on limits. */ + VDUP(vector, , int, s, 8, 8, 0); + VDUP(vector, , int, s, 16, 4, 0); + VDUP(vector, , int, s, 32, 2, 0); + VDUP(vector, , int, s, 64, 1, 0); + VDUP(vector, , uint, u, 8, 8, 0); + VDUP(vector, , uint, u, 16, 4, 0); + VDUP(vector, , uint, u, 32, 2, 0); + VDUP(vector, , uint, u, 64, 1, 0); + VDUP(vector, q, int, s, 8, 16, 0); + VDUP(vector, q, int, s, 16, 8, 0); + VDUP(vector, q, int, s, 32, 4, 0); + VDUP(vector, q, int, s, 64, 2, 0); + VDUP(vector, q, uint, u, 8, 16, 0); + VDUP(vector, q, uint, u, 16, 8, 0); + VDUP(vector, q, uint, u, 32, 4, 0); + VDUP(vector, q, uint, u, 64, 2, 0); + + /* Choose init value arbitrarily, will be used as shift amount */ + /* Use values equal or one-less-than the type width to check + behaviour on limits. */ + + /* 64-bits vectors first. */ + /* Shift 8-bits lanes by 7... */ + VDUP(vector_shift, , int, s, 8, 8, 7); + /* ... except: lane 0 (by 6), lane 1 (by 8) and lane 2 (by 9). */ + VSET_LANE(vector_shift, , int, s, 8, 8, 0, 6); + VSET_LANE(vector_shift, , int, s, 8, 8, 1, 8); + VSET_LANE(vector_shift, , int, s, 8, 8, 2, 9); + + /* Shift 16-bits lanes by 15... */ + VDUP(vector_shift, , int, s, 16, 4, 15); + /* ... except: lane 0 (by 14), lane 1 (by 16), and lane 2 (by 17). */ + VSET_LANE(vector_shift, , int, s, 16, 4, 0, 14); + VSET_LANE(vector_shift, , int, s, 16, 4, 1, 16); + VSET_LANE(vector_shift, , int, s, 16, 4, 2, 17); + + /* Shift 32-bits lanes by 31... */ + VDUP(vector_shift, , int, s, 32, 2, 31); + /* ... except lane 1 (by 30). */ + VSET_LANE(vector_shift, , int, s, 32, 2, 1, 30); + + /* Shift 64 bits lane by 63. */ + VDUP(vector_shift, , int, s, 64, 1, 63); + + /* 128-bits vectors. */ + /* Shift 8-bits lanes by 8. */ + VDUP(vector_shift, q, int, s, 8, 16, 8); + /* Shift 16-bits lanes by 16. */ + VDUP(vector_shift, q, int, s, 16, 8, 16); + /* Shift 32-bits lanes by 32... */ + VDUP(vector_shift, q, int, s, 32, 4, 32); + /* ... except lane 1 (by 33). */ + VSET_LANE(vector_shift, q, int, s, 32, 4, 1, 33); + + /* Shift 64-bits lanes by 64... */ + VDUP(vector_shift, q, int, s, 64, 2, 64); + /* ... except lane 1 (by 62). */ + VSET_LANE(vector_shift, q, int, s, 64, 2, 1, 62); + +#define CMT " (with input = 0)" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat_0, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat_0, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_0, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_0, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_0, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_0, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_0, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_0, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_0, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_0, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_0, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_0, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_0, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_0, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_0, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_0, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_0, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_0, CMT); + + + /* Use negative shift amounts */ + VDUP(vector_shift, , int, s, 8, 8, -1); + VDUP(vector_shift, , int, s, 16, 4, -2); + VDUP(vector_shift, , int, s, 32, 2, -3); + VDUP(vector_shift, , int, s, 64, 1, -4); + VDUP(vector_shift, q, int, s, 8, 16, -7); + VDUP(vector_shift, q, int, s, 16, 8, -11); + VDUP(vector_shift, q, int, s, 32, 4, -13); + VDUP(vector_shift, q, int, s, 64, 2, -20); + +#undef CMT +#define CMT " (input 0 and negative shift amount)" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat_0_neg, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat_0_neg, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_0_neg, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_0_neg, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_0_neg, CMT); + + /* Test again, with predefined input values. */ + TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer); + + /* Choose init value arbitrarily, will be used as shift amount. */ + VDUP(vector_shift, , int, s, 8, 8, 1); + VDUP(vector_shift, , int, s, 16, 4, 3); + VDUP(vector_shift, , int, s, 32, 2, 8); + VDUP(vector_shift, , int, s, 64, 1, -3); + VDUP(vector_shift, q, int, s, 8, 16, 10); + VDUP(vector_shift, q, int, s, 16, 8, 12); + VDUP(vector_shift, q, int, s, 32, 4, 32); + VDUP(vector_shift, q, int, s, 64, 2, 63); + +#undef CMT +#define CMT "" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected, CMT); + + + /* Use negative shift amounts */ + VDUP(vector_shift, , int, s, 8, 8, -1); + VDUP(vector_shift, , int, s, 16, 4, -2); + VDUP(vector_shift, , int, s, 32, 2, -3); + VDUP(vector_shift, , int, s, 64, 1, -4); + VDUP(vector_shift, q, int, s, 8, 16, -7); + VDUP(vector_shift, q, int, s, 16, 8, -11); + VDUP(vector_shift, q, int, s, 32, 4, -13); + VDUP(vector_shift, q, int, s, 64, 2, -20); + +#undef CMT +#define CMT " (negative shift amount)" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat_neg, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat_neg, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_neg, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_neg, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_neg, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_neg, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_neg, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_neg, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_neg, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_neg, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_neg, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_neg, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_neg, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_neg, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_neg, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_neg, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_neg, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_neg, CMT); + + + /* Use large shift amounts. */ + VDUP(vector_shift, , int, s, 8, 8, 8); + VDUP(vector_shift, , int, s, 16, 4, 16); + VDUP(vector_shift, , int, s, 32, 2, 32); + VDUP(vector_shift, , int, s, 64, 1, 64); + VDUP(vector_shift, q, int, s, 8, 16, 8); + VDUP(vector_shift, q, int, s, 16, 8, 16); + VDUP(vector_shift, q, int, s, 32, 4, 32); + VDUP(vector_shift, q, int, s, 64, 2, 64); + +#undef CMT +#define CMT " (large shift amount, negative input)" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat_neg_large, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat_neg_large, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_neg_large, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_neg_large, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_neg_large, CMT); + + + /* Fill input vector with max value, to check saturation on limits */ + VDUP(vector, , int, s, 8, 8, 0x7F); + VDUP(vector, , int, s, 16, 4, 0x7FFF); + VDUP(vector, , int, s, 32, 2, 0x7FFFFFFF); + VDUP(vector, , int, s, 64, 1, 0x7FFFFFFFFFFFFFFFLL); + VDUP(vector, , uint, u, 8, 8, 0xFF); + VDUP(vector, , uint, u, 16, 4, 0xFFFF); + VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF); + VDUP(vector, , uint, u, 64, 1, 0xFFFFFFFFFFFFFFFFULL); + VDUP(vector, q, int, s, 8, 16, 0x7F); + VDUP(vector, q, int, s, 16, 8, 0x7FFF); + VDUP(vector, q, int, s, 32, 4, 0x7FFFFFFF); + VDUP(vector, q, int, s, 64, 2, 0x7FFFFFFFFFFFFFFFLL); + VDUP(vector, q, uint, u, 8, 16, 0xFF); + VDUP(vector, q, uint, u, 16, 8, 0xFFFF); + VDUP(vector, q, uint, u, 32, 4, 0xFFFFFFFF); + VDUP(vector, q, uint, u, 64, 2, 0xFFFFFFFFFFFFFFFFULL); + + /* Shift by -1 */ + VDUP(vector_shift, , int, s, 8, 8, -1); + VDUP(vector_shift, , int, s, 16, 4, -1); + VDUP(vector_shift, , int, s, 32, 2, -1); + VDUP(vector_shift, , int, s, 64, 1, -1); + VDUP(vector_shift, q, int, s, 8, 16, -1); + VDUP(vector_shift, q, int, s, 16, 8, -1); + VDUP(vector_shift, q, int, s, 32, 4, -1); + VDUP(vector_shift, q, int, s, 64, 2, -1); + +#undef CMT +#define CMT " (max input, shift by -1)" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat_max_minus1, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat_max_minus1, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_minus1, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_minus1, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_minus1, CMT); + + + /* Use large shift amounts */ + VDUP(vector_shift, , int, s, 8, 8, 8); + VDUP(vector_shift, , int, s, 16, 4, 16); + VDUP(vector_shift, , int, s, 32, 2, 32); + VDUP(vector_shift, , int, s, 64, 1, 64); + VDUP(vector_shift, q, int, s, 8, 16, 8); + VDUP(vector_shift, q, int, s, 16, 8, 16); + VDUP(vector_shift, q, int, s, 32, 4, 32); + VDUP(vector_shift, q, int, s, 64, 2, 64); + +#undef CMT +#define CMT " (max input, large shift amount)" + TEST_VQSHL(int, , int, s, 8, 8, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , int, s, 16, 4, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , int, s, 32, 2, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , uint, u, 8, 8, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , uint, u, 16, 4, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , uint, u, 32, 2, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, , uint, u, 64, 1, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, int, s, 8, 16, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, int, s, 16, 8, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, int, s, 32, 4, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, uint, u, 8, 16, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, uint, u, 16, 8, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, uint, u, 32, 4, expected_cumulative_sat_max_large, CMT); + TEST_VQSHL(int, q, uint, u, 64, 2, expected_cumulative_sat_max_large, CMT); + + CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_max_large, CMT); + CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_max_large, CMT); + CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_max_large, CMT); + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_max_large, CMT); + CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_max_large, CMT); + CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_max_large, CMT); + CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_max_large, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_max_large, CMT); + CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_max_large, CMT); + + + /* Check 64 bits saturation. */ + VDUP(vector, , int, s, 64, 1, -10); + VDUP(vector_shift, , int, s, 64, 1, 64); + VDUP(vector, q, int, s, 64, 2, 10); + VDUP(vector_shift, q, int, s, 64, 2, 64); + +#undef CMT +#define CMT " (check saturation on 64 bits)" + TEST_VQSHL(int, , int, s, 64, 1, expected_cumulative_sat_64, CMT); + TEST_VQSHL(int, q, int, s, 64, 2, expected_cumulative_sat_64, CMT); + + CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_64, CMT); + CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_64, CMT); +} + +int main (void) +{ + exec_vqshl (); + return 0; +}