From patchwork Mon Oct 18 08:59:27 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?q?Martin_Li=C5=A1ka?= X-Patchwork-Id: 46331 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A63DE3858400 for ; Mon, 18 Oct 2021 09:00:15 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.220.28]) by sourceware.org (Postfix) with ESMTPS id 154B63858C39 for ; Mon, 18 Oct 2021 08:59:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 154B63858C39 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=suse.cz Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=suse.cz Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id D65E521940; Mon, 18 Oct 2021 08:59:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_rsa; t=1634547567; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=1g4PTQisR5p29XpPtSy5F0ONzNX0ax6PL6xq8a+d95Q=; b=CzFMW9BXzLNaNOoy/iwW0SrbVngkWRYadH+6INKGWGBUnYaU+eSHxU0N4UCeLZk2ij8MQQ xv5ByoAlkBRhg+ykM3qudScUEgPQgumKRF2j9uwnHorhvnghROmEFwnwajdHD/5gsz4UVS rfS1HU27L3nwABZHGwCWhP+NuatStaU= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_ed25519; t=1634547567; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=1g4PTQisR5p29XpPtSy5F0ONzNX0ax6PL6xq8a+d95Q=; b=K3UyhqP42khMuKq8eaeGb3uDaK98x4ZOp4+gnnSqLw3GyjUudOaS7KTTEIqSb+tjZju0MS b+HIQQVayTyTr8Aw== Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by imap2.suse-dmz.suse.de (Postfix) with ESMTPS id B025A13C89; Mon, 18 Oct 2021 08:59:27 +0000 (UTC) Received: from dovecot-director2.suse.de ([192.168.254.65]) by imap2.suse-dmz.suse.de with ESMTPSA id I3DRKW83bWFzPAAAMHmgww (envelope-from ); Mon, 18 Oct 2021 08:59:27 +0000 Message-ID: <13efb730-e52a-158e-7a60-54c204434b77@suse.cz> Date: Mon, 18 Oct 2021 10:59:27 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.2.0 From: =?utf-8?q?Martin_Li=C5=A1ka?= Subject: [PATCH] Add TSVC tests. To: gcc-patches@gcc.gnu.org Content-Language: en-US X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jan Hubicka Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" Hello. The ambition of the patch is addition of TSVC_2 loop tests to GCC test-suite: https://github.com/UoB-HPC/TSVC_2 Right now, I add only compile tests where I scan for number of loops vectorized. Patch can bootstrap on x86_64-linux-gnu and survives regression tests. Thoughts? Thanks, Martin gcc/testsuite/ChangeLog: * gcc.dg/vect/license.txt: New test. * gcc.dg/vect/tsvc.h: New test. * gcc.dg/vect/vect-tsvc-s000.c: New test. * gcc.dg/vect/vect-tsvc-s111.c: New test. * gcc.dg/vect/vect-tsvc-s1111.c: New test. * gcc.dg/vect/vect-tsvc-s1112.c: New test. * gcc.dg/vect/vect-tsvc-s1113.c: New test. * gcc.dg/vect/vect-tsvc-s1115.c: New test. * gcc.dg/vect/vect-tsvc-s1119.c: New test. * gcc.dg/vect/vect-tsvc-s112.c: New test. * gcc.dg/vect/vect-tsvc-s113.c: New test. * gcc.dg/vect/vect-tsvc-s114.c: New test. * gcc.dg/vect/vect-tsvc-s115.c: New test. * gcc.dg/vect/vect-tsvc-s116.c: New test. * gcc.dg/vect/vect-tsvc-s1161.c: New test. * gcc.dg/vect/vect-tsvc-s118.c: New test. * gcc.dg/vect/vect-tsvc-s119.c: New test. * gcc.dg/vect/vect-tsvc-s121.c: New test. * gcc.dg/vect/vect-tsvc-s1213.c: New test. * gcc.dg/vect/vect-tsvc-s122.c: New test. * gcc.dg/vect/vect-tsvc-s1221.c: New test. * gcc.dg/vect/vect-tsvc-s123.c: New test. * gcc.dg/vect/vect-tsvc-s1232.c: New test. * gcc.dg/vect/vect-tsvc-s124.c: New test. * gcc.dg/vect/vect-tsvc-s1244.c: New test. * gcc.dg/vect/vect-tsvc-s125.c: New test. * gcc.dg/vect/vect-tsvc-s1251.c: New test. * gcc.dg/vect/vect-tsvc-s126.c: New test. * gcc.dg/vect/vect-tsvc-s127.c: New test. * gcc.dg/vect/vect-tsvc-s1279.c: New test. * gcc.dg/vect/vect-tsvc-s128.c: New test. * gcc.dg/vect/vect-tsvc-s1281.c: New test. * gcc.dg/vect/vect-tsvc-s131.c: New test. * gcc.dg/vect/vect-tsvc-s13110.c: New test. * gcc.dg/vect/vect-tsvc-s132.c: New test. * gcc.dg/vect/vect-tsvc-s1351.c: New test. * gcc.dg/vect/vect-tsvc-s141.c: New test. * gcc.dg/vect/vect-tsvc-s1421.c: New test. * gcc.dg/vect/vect-tsvc-s151.c: New test. * gcc.dg/vect/vect-tsvc-s152.c: New test. * gcc.dg/vect/vect-tsvc-s161.c: New test. * gcc.dg/vect/vect-tsvc-s162.c: New test. * gcc.dg/vect/vect-tsvc-s171.c: New test. * gcc.dg/vect/vect-tsvc-s172.c: New test. * gcc.dg/vect/vect-tsvc-s173.c: New test. * gcc.dg/vect/vect-tsvc-s174.c: New test. * gcc.dg/vect/vect-tsvc-s175.c: New test. * gcc.dg/vect/vect-tsvc-s176.c: New test. * gcc.dg/vect/vect-tsvc-s2101.c: New test. * gcc.dg/vect/vect-tsvc-s2102.c: New test. * gcc.dg/vect/vect-tsvc-s211.c: New test. * gcc.dg/vect/vect-tsvc-s2111.c: New test. * gcc.dg/vect/vect-tsvc-s212.c: New test. * gcc.dg/vect/vect-tsvc-s221.c: New test. * gcc.dg/vect/vect-tsvc-s222.c: New test. * gcc.dg/vect/vect-tsvc-s2233.c: New test. * gcc.dg/vect/vect-tsvc-s2244.c: New test. * gcc.dg/vect/vect-tsvc-s2251.c: New test. * gcc.dg/vect/vect-tsvc-s2275.c: New test. * gcc.dg/vect/vect-tsvc-s231.c: New test. * gcc.dg/vect/vect-tsvc-s232.c: New test. * gcc.dg/vect/vect-tsvc-s233.c: New test. * gcc.dg/vect/vect-tsvc-s235.c: New test. * gcc.dg/vect/vect-tsvc-s241.c: New test. * gcc.dg/vect/vect-tsvc-s242.c: New test. * gcc.dg/vect/vect-tsvc-s243.c: New test. * gcc.dg/vect/vect-tsvc-s244.c: New test. * gcc.dg/vect/vect-tsvc-s251.c: New test. * gcc.dg/vect/vect-tsvc-s252.c: New test. * gcc.dg/vect/vect-tsvc-s253.c: New test. * gcc.dg/vect/vect-tsvc-s254.c: New test. * gcc.dg/vect/vect-tsvc-s255.c: New test. * gcc.dg/vect/vect-tsvc-s256.c: New test. * gcc.dg/vect/vect-tsvc-s257.c: New test. * gcc.dg/vect/vect-tsvc-s258.c: New test. * gcc.dg/vect/vect-tsvc-s261.c: New test. * gcc.dg/vect/vect-tsvc-s271.c: New test. * gcc.dg/vect/vect-tsvc-s2710.c: New test. * gcc.dg/vect/vect-tsvc-s2711.c: New test. * gcc.dg/vect/vect-tsvc-s2712.c: New test. * gcc.dg/vect/vect-tsvc-s272.c: New test. * gcc.dg/vect/vect-tsvc-s273.c: New test. * gcc.dg/vect/vect-tsvc-s274.c: New test. * gcc.dg/vect/vect-tsvc-s275.c: New test. * gcc.dg/vect/vect-tsvc-s276.c: New test. * gcc.dg/vect/vect-tsvc-s277.c: New test. * gcc.dg/vect/vect-tsvc-s278.c: New test. * gcc.dg/vect/vect-tsvc-s279.c: New test. * gcc.dg/vect/vect-tsvc-s281.c: New test. * gcc.dg/vect/vect-tsvc-s291.c: New test. * gcc.dg/vect/vect-tsvc-s292.c: New test. * gcc.dg/vect/vect-tsvc-s293.c: New test. * gcc.dg/vect/vect-tsvc-s311.c: New test. * gcc.dg/vect/vect-tsvc-s3110.c: New test. * gcc.dg/vect/vect-tsvc-s3111.c: New test. * gcc.dg/vect/vect-tsvc-s31111.c: New test. * gcc.dg/vect/vect-tsvc-s3112.c: New test. * gcc.dg/vect/vect-tsvc-s3113.c: New test. * gcc.dg/vect/vect-tsvc-s312.c: New test. * gcc.dg/vect/vect-tsvc-s313.c: New test. * gcc.dg/vect/vect-tsvc-s314.c: New test. * gcc.dg/vect/vect-tsvc-s315.c: New test. * gcc.dg/vect/vect-tsvc-s316.c: New test. * gcc.dg/vect/vect-tsvc-s317.c: New test. * gcc.dg/vect/vect-tsvc-s318.c: New test. * gcc.dg/vect/vect-tsvc-s319.c: New test. * gcc.dg/vect/vect-tsvc-s321.c: New test. * gcc.dg/vect/vect-tsvc-s322.c: New test. * gcc.dg/vect/vect-tsvc-s323.c: New test. * gcc.dg/vect/vect-tsvc-s3251.c: New test. * gcc.dg/vect/vect-tsvc-s331.c: New test. * gcc.dg/vect/vect-tsvc-s332.c: New test. * gcc.dg/vect/vect-tsvc-s341.c: New test. * gcc.dg/vect/vect-tsvc-s342.c: New test. * gcc.dg/vect/vect-tsvc-s343.c: New test. * gcc.dg/vect/vect-tsvc-s351.c: New test. * gcc.dg/vect/vect-tsvc-s352.c: New test. * gcc.dg/vect/vect-tsvc-s353.c: New test. * gcc.dg/vect/vect-tsvc-s4112.c: New test. * gcc.dg/vect/vect-tsvc-s4113.c: New test. * gcc.dg/vect/vect-tsvc-s4114.c: New test. * gcc.dg/vect/vect-tsvc-s4115.c: New test. * gcc.dg/vect/vect-tsvc-s4116.c: New test. * gcc.dg/vect/vect-tsvc-s4117.c: New test. * gcc.dg/vect/vect-tsvc-s4121.c: New test. * gcc.dg/vect/vect-tsvc-s421.c: New test. * gcc.dg/vect/vect-tsvc-s422.c: New test. * gcc.dg/vect/vect-tsvc-s423.c: New test. * gcc.dg/vect/vect-tsvc-s424.c: New test. * gcc.dg/vect/vect-tsvc-s431.c: New test. * gcc.dg/vect/vect-tsvc-s441.c: New test. * gcc.dg/vect/vect-tsvc-s442.c: New test. * gcc.dg/vect/vect-tsvc-s443.c: New test. * gcc.dg/vect/vect-tsvc-s451.c: New test. * gcc.dg/vect/vect-tsvc-s452.c: New test. * gcc.dg/vect/vect-tsvc-s453.c: New test. * gcc.dg/vect/vect-tsvc-s471.c: New test. * gcc.dg/vect/vect-tsvc-s481.c: New test. * gcc.dg/vect/vect-tsvc-s482.c: New test. * gcc.dg/vect/vect-tsvc-s491.c: New test. * gcc.dg/vect/vect-tsvc-va.c: New test. * gcc.dg/vect/vect-tsvc-vag.c: New test. * gcc.dg/vect/vect-tsvc-vas.c: New test. * gcc.dg/vect/vect-tsvc-vbor.c: New test. * gcc.dg/vect/vect-tsvc-vdotr.c: New test. * gcc.dg/vect/vect-tsvc-vif.c: New test. * gcc.dg/vect/vect-tsvc-vpv.c: New test. * gcc.dg/vect/vect-tsvc-vpvpv.c: New test. * gcc.dg/vect/vect-tsvc-vpvts.c: New test. * gcc.dg/vect/vect-tsvc-vpvtv.c: New test. * gcc.dg/vect/vect-tsvc-vsumr.c: New test. * gcc.dg/vect/vect-tsvc-vtv.c: New test. * gcc.dg/vect/vect-tsvc-vtvtv.c: New test. --- gcc/testsuite/gcc.dg/vect/license.txt | 58 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/tsvc.h | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c | 31 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c | 32 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c | 30 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c | 30 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c | 29 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c | 34 ++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c | 29 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c | 30 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c | 31 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c | 21 +++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c | 35 ++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c | 32 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c | 30 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c | 34 ++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c | 35 ++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c | 38 +++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c | 34 ++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c | 34 ++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c | 29 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c | 32 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c | 30 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c | 30 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c | 33 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c | 33 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c | 26 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c | 27 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c | 28 ++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c | 40 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c | 33 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c | 33 +++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c | 22 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c | 38 +++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c | 24 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c | 25 +++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c | 23 ++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c | 23 ++++++++ 153 files changed, 4044 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/vect/license.txt create mode 100644 gcc/testsuite/gcc.dg/vect/tsvc.h create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c diff --git a/gcc/testsuite/gcc.dg/vect/license.txt b/gcc/testsuite/gcc.dg/vect/license.txt new file mode 100644 index 00000000000..782154d4adf --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/license.txt @@ -0,0 +1,58 @@ +Copyright (c) 2011 University of Illinois at Urbana-Champaign. All rights reserved. + + + +Developed by: Polaris Research Group + + University of Illinois at Urbana-Champaign + + http://polaris.cs.uiuc.edu + + + +Permission is hereby granted, free of charge, to any person obtaining a copy + +of this software and associated documentation files (the "Software"), to + +deal with the Software without restriction, including without limitation the + +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + +sell copies of the Software, and to permit persons to whom the Software is + +furnished to do so, subject to the following conditions: + + 1. Redistributions of source code must retain the above copyright notice, + + this list of conditions and the following disclaimers. + + 2. Redistributions in binary form must reproduce the above copyright + + notice, this list of conditions and the following disclaimers in the + + documentation and/or other materials provided with the distribution. + + 3. Neither the names of Polaris Research Group, University of Illinois at + + Urbana-Champaign, nor the names of its contributors may be used to endorse + + or promote products derived from this Software without specific prior + + written permission. + + + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + +CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + +WITH THE SOFTWARE. + diff --git a/gcc/testsuite/gcc.dg/vect/tsvc.h b/gcc/testsuite/gcc.dg/vect/tsvc.h new file mode 100644 index 00000000000..cfc00cba0c5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc.h @@ -0,0 +1,25 @@ +#define iterations 100000 +#define LEN_1D 32000 +#define LEN_2D 256 +#define ARRAY_ALIGNMENT 64 + +#include +#include + +typedef float real_t; +#define ABS fabsf + +int dummy(real_t[LEN_1D], real_t[LEN_1D], real_t[LEN_1D], real_t[LEN_1D], + real_t[LEN_1D], real_t[LEN_2D][LEN_2D], real_t[LEN_2D][LEN_2D], + real_t[LEN_2D][LEN_2D], real_t); + +extern __attribute__((aligned(ARRAY_ALIGNMENT))) +real_t flat_2d_array[LEN_2D * LEN_2D]; +extern __attribute__((aligned(ARRAY_ALIGNMENT))) real_t x[LEN_1D]; +extern __attribute__((aligned(ARRAY_ALIGNMENT))) real_t a[LEN_1D], b[LEN_1D], + c[LEN_1D], d[LEN_1D], e[LEN_1D], aa[LEN_2D][LEN_2D], bb[LEN_2D][LEN_2D], + cc[LEN_2D][LEN_2D], tt[LEN_2D][LEN_2D]; +extern __attribute__((aligned(ARRAY_ALIGNMENT))) int indx[LEN_1D]; + +extern real_t* __restrict__ xx; +extern real_t* yy; diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c new file mode 100644 index 00000000000..c6c57404757 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s000 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i] + 1; + } + dummy((real_t*)a, (real_t*)b, (real_t*)c, (real_t*)d, (real_t*)e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c new file mode 100644 index 00000000000..b63fb6ddaf7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s111 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 1; i < LEN_1D; i += 2) { + a[i] = a[i - 1] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c new file mode 100644 index 00000000000..e7c5a75424b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1111 (void) +{ +// no dependence - vectorizable +// jump in data access + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D/2; i++) { + a[2*i] = c[i] * b[i] + d[i] * b[i] + c[i] * c[i] + d[i] * b[i] + d[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c new file mode 100644 index 00000000000..80e8a71b543 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1112 (void) +{ +// linear dependence testing +// loop reversal + + + for (int nl = 0; nl < iterations*3; nl++) { + for (int i = LEN_1D - 1; i >= 0; i--) { + a[i] = b[i] + (real_t) 1.; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c new file mode 100644 index 00000000000..c26ac752230 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1113 (void) +{ +// linear dependence testing +// one iteration dependency on a(LEN_1D/2) but still vectorizable + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[LEN_1D/2] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c new file mode 100644 index 00000000000..cf1ace4b4da --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1115 (void) +{ +// linear dependence testing +// triangular saxpy loop + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[i][j] = aa[i][j]*cc[j][i] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c new file mode 100644 index 00000000000..61a531907b9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1119 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[i][j] = aa[i-1][j] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c new file mode 100644 index 00000000000..9025825ef94 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s112 (void) +{ +// linear dependence testing +// loop reversal + + + for (int nl = 0; nl < 3*iterations; nl++) { + for (int i = LEN_1D - 2; i >= 0; i--) { + a[i+1] = a[i] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c new file mode 100644 index 00000000000..4cdb8c0edeb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s113 (void) +{ +// linear dependence testing +// a(i)=a(1) but no actual dependence cycle + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] = a[0] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c new file mode 100644 index 00000000000..f532c95421e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s114 (void) +{ +// linear dependence testing +// transpose vectorization +// Jump in data access - not vectorizable + + + for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < i; j++) { + aa[i][j] = aa[j][i] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c new file mode 100644 index 00000000000..75f1c4e72dd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s115 (void) +{ +// linear dependence testing +// triangular saxpy loop + + + for (int nl = 0; nl < 1000*(iterations/LEN_2D); nl++) { + for (int j = 0; j < LEN_2D; j++) { + for (int i = j+1; i < LEN_2D; i++) { + a[i] -= aa[j][i] * a[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c new file mode 100644 index 00000000000..3806e87e16b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s116 (void) +{ +// linear dependence testing + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D - 5; i += 5) { + a[i] = a[i + 1] * a[i]; + a[i + 1] = a[i + 2] * a[i + 1]; + a[i + 2] = a[i + 3] * a[i + 2]; + a[i + 3] = a[i + 4] * a[i + 3]; + a[i + 4] = a[i + 5] * a[i + 4]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c new file mode 100644 index 00000000000..7a3303f87e3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c @@ -0,0 +1,31 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1161 (void) +{ +// control flow +// tests for recognition of loop independent dependences +// between statements in mutually exclusive regions. + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; ++i) { + if (c[i] < (real_t)0.) { + goto L20; + } + a[i] = c[i] + d[i] * e[i]; + goto L10; +L20: + b[i] = a[i] + d[i] * d[i]; +L10: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c new file mode 100644 index 00000000000..290839919da --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s118 (void) +{ +// linear dependence testing +// potential dot product recursion + + + for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 0; j <= i - 1; j++) { + a[i] += bb[j][i] * a[i-j-1]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c new file mode 100644 index 00000000000..2b98fa5467f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s119 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + aa[i][j] = aa[i-1][j-1] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c new file mode 100644 index 00000000000..f8d1cc055cd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s121 (void) +{ +// induction variable recognition +// loop with possible ambiguity because of scalar store + + + int j; + for (int nl = 0; nl < 3*iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + j = i + 1; + a[i] = a[j] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c new file mode 100644 index 00000000000..ad103d0fe59 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1213 (void) +{ +// statement reordering +// dependency needing temporary + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D-1; i++) { + a[i] = b[i-1]+c[i]; + b[i] = a[i+1]*d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c new file mode 100644 index 00000000000..e8d294b9f92 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c @@ -0,0 +1,32 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int a;int b;}; + +void s122 (struct arg *x) +{ +// induction variable recognition +// variable lower and upper bound, and stride +// reverse data access and jump in data access + + int n1 = x->a; + int n3 = x->b; + + + int j, k; + for (int nl = 0; nl < iterations; nl++) { + j = 1; + k = 0; + for (int i = n1-1; i < LEN_1D; i += n3) { + k += j; + a[i] += b[LEN_1D - k]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c new file mode 100644 index 00000000000..7992a65aae5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1221 (void) +{ +// run-time symbolic resolution + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 4; i < LEN_1D; i++) { + b[i] = b[i - 4] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c new file mode 100644 index 00000000000..f17d5913a54 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c @@ -0,0 +1,30 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s123 (void) +{ +// induction variable recognition +// induction variable under an if +// not vectorizable, the condition cannot be speculated + + + int j; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < (LEN_1D/2); i++) { + j++; + a[j] = b[i] + d[i] * e[i]; + if (c[i] > (real_t)0.) { + j++; + a[j] = c[i] + d[i] * e[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c new file mode 100644 index 00000000000..128804aed75 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1232 (void) +{ +// loop interchange +// interchanging of triangular loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int j = 0; j < LEN_2D; j++) { + for (int i = j; i < LEN_2D; i++) { + aa[i][j] = bb[i][j] + cc[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c new file mode 100644 index 00000000000..4a23eeadbcf --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c @@ -0,0 +1,30 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s124 (void) +{ +// induction variable recognition +// induction variable under both sides of if (same value) + + + int j; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + j++; + a[j] = b[i] + d[i] * e[i]; + } else { + j++; + a[j] = c[i] + d[i] * e[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c new file mode 100644 index 00000000000..add25a328eb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1244 (void) +{ +// node splitting +// cycle with ture and anti dependency + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = b[i] + c[i] * c[i] + b[i]*b[i] + c[i]; + d[i] = a[i] + a[i+1]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c new file mode 100644 index 00000000000..871154c3786 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s125 (void) +{ +// induction variable recognition +// induction variable in two loops; collapsing possible + + + int k; + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + k = -1; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + k++; + flat_2d_array[k] = aa[i][j] + bb[i][j] * cc[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c new file mode 100644 index 00000000000..a6cc3a42e1d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1251 (void) +{ +// scalar and array expansion +// scalar expansion + + + real_t s; + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + s = b[i]+c[i]; + b[i] = a[i]+d[i]; + a[i] = s*e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c new file mode 100644 index 00000000000..011e5ce08e5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s126 (void) +{ +// induction variable recognition +// induction variable in two loops; recurrence in inner loop + + + int k; + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + k = 1; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + bb[j][i] = bb[j-1][i] + flat_2d_array[k-1] * cc[j][i]; + ++k; + } + ++k; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c new file mode 100644 index 00000000000..b1cd4f99eff --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s127 (void) +{ +// induction variable recognition +// induction variable with multiple increments + + + int j; + for (int nl = 0; nl < 2*iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D/2; i++) { + j++; + a[j] = b[i] + c[i] * d[i]; + j++; + a[j] = b[i] + d[i] * e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c new file mode 100644 index 00000000000..90cd2cec47b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1279 (void) +{ +// control flow +// vector if/gotos + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] < (real_t)0.) { + if (b[i] > a[i]) { + c[i] += d[i] * e[i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c new file mode 100644 index 00000000000..3356b16fe1e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c @@ -0,0 +1,29 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s128 (void) +{ +// induction variables +// coupled induction variables +// jump in data access + + + int j, k; + for (int nl = 0; nl < 2*iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D/2; i++) { + k = j + 1; + a[i] = b[k] - d[i]; + j = k + 1; + b[k] = a[i] + c[k]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c new file mode 100644 index 00000000000..8534b71a1a4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1281 (void) +{ +// crossing thresholds +// index set splitting +// reverse data access + + + real_t x; + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + x = b[i]*c[i] + a[i]*d[i] + e[i]; + a[i] = x-(real_t)1.0; + b[i] = x; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c new file mode 100644 index 00000000000..377b841d298 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s131 (void) +{ +// global data flow analysis +// forward substitution + + + int m = 1; + for (int nl = 0; nl < 5*iterations; nl++) { + for (int i = 0; i < LEN_1D - 1; i++) { + a[i] = a[i + m] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c new file mode 100644 index 00000000000..efc3b61d7e1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c @@ -0,0 +1,34 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s13110 (void) +{ +// reductions +// if to max with index reductio 2 dimensions + + + int xindex, yindex; + real_t max, chksum; + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + max = aa[(0)][0]; + xindex = 0; + yindex = 0; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + if (aa[i][j] > max) { + max = aa[i][j]; + xindex = i; + yindex = j; + } + } + } + chksum = max + (real_t) xindex + (real_t) yindex; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c new file mode 100644 index 00000000000..1837e11aa2c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s132 (void) +{ +// global data flow analysis +// loop with multiple dimension ambiguous subscripts + + + int m = 0; + int j = m; + int k = m+1; + for (int nl = 0; nl < 400*iterations; nl++) { + for (int i= 1; i < LEN_2D; i++) { + aa[j][i] = aa[k][i-1] + b[i] * c[1]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c new file mode 100644 index 00000000000..fddaefb8e66 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1351 (void) +{ +// induction pointer recognition + + + for (int nl = 0; nl < 8*iterations; nl++) { + real_t* __restrict__ A = a; + real_t* __restrict__ B = b; + real_t* __restrict__ C = c; + for (int i = 0; i < LEN_1D; i++) { + *A = *B+*C; + A++; + B++; + C++; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c new file mode 100644 index 00000000000..9ea1df48331 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s141 (void) +{ +// nonlinear dependence testing +// walk a row in a symmetric packed array +// element a(i,j) for (int j>i) stored in location j*(j-1)/2+i + + + int k; + for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + k = (i+1) * ((i+1) - 1) / 2 + (i+1)-1; + for (int j = i; j < LEN_2D; j++) { + flat_2d_array[k] += bb[j][i]; + k += j+1; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c new file mode 100644 index 00000000000..947e761f869 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1421 (void) +{ +// storage classes and equivalencing +// equivalence- no overlap + + + xx = &b[LEN_1D/2]; + + for (int nl = 0; nl < 8*iterations; nl++) { + for (int i = 0; i < LEN_1D/2; i++) { + b[i] = xx[i] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c new file mode 100644 index 00000000000..f04bdfa6c8c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c @@ -0,0 +1,29 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s151s(real_t a[LEN_1D], real_t b[LEN_1D], int m) +{ + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = a[i + m] + b[i]; + } +} + +void s151 (void) +{ +// interprocedural data flow analysis +// passing parameter information into a subroutine + + + for (int nl = 0; nl < 5*iterations; nl++) { + s151s(a, b, 1); + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c new file mode 100644 index 00000000000..6ad1eb3a632 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c @@ -0,0 +1,30 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s152s(real_t a[LEN_1D], real_t b[LEN_1D], real_t c[LEN_1D], int i) +{ + a[i] += b[i] * c[i]; +} + +void s152 (void) +{ +// interprocedural data flow analysis +// collecting information from a subroutine + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + b[i] = d[i] * e[i]; + s152s(a, b, c, i); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c new file mode 100644 index 00000000000..4bfa9a490ef --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c @@ -0,0 +1,31 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s161 (void) +{ +// control flow +// tests for recognition of loop independent dependences +// between statements in mutually exclusive regions. + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D-1; ++i) { + if (b[i] < (real_t)0.) { + goto L20; + } + a[i] = c[i] + d[i] * e[i]; + goto L10; +L20: + c[i+1] = a[i] + d[i] * d[i]; +L10: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c new file mode 100644 index 00000000000..60f86fc61d9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s162 (int k) +{ +// control flow +// deriving assertions + + for (int nl = 0; nl < iterations; nl++) { + if (k > 0) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = a[i + k] + b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c new file mode 100644 index 00000000000..dd2e425ee20 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s171 (int inc) +{ +// symbolics +// symbolic dependence tests + + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i * inc] += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c new file mode 100644 index 00000000000..a15355fcb64 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int a;int b;}; + +void s172 (struct arg *x) +{ +// symbolics +// vectorizable if n3 .ne. 0 + + int n1 = x->a; + int n3 = x->b; + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = n1-1; i < LEN_1D; i += n3) { + a[i] += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c new file mode 100644 index 00000000000..def1c4eb22d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s173 (void) +{ +// symbolics +// expression in loop bounds and subscripts + + + int k = LEN_1D/2; + for (int nl = 0; nl < 10*iterations; nl++) { + for (int i = 0; i < LEN_1D/2; i++) { + a[i+k] = a[i] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c new file mode 100644 index 00000000000..f0488fded38 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s174 (int M) +{ +// symbolics +// loop with subscript that may seem ambiguous + + for (int nl = 0; nl < 10*iterations; nl++) { + for (int i = 0; i < M; i++) { + a[i+M] = a[i] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c new file mode 100644 index 00000000000..82825d0a27a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c @@ -0,0 +1,21 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s175 (int inc) +{ +// symbolics +// symbolic dependence tests + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i += inc) { + a[i] = a[i + inc] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c new file mode 100644 index 00000000000..f7b79b5ee43 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s176 (void) +{ +// symbolics +// convolution + + + int m = LEN_1D/2; + for (int nl = 0; nl < 4*(iterations/LEN_1D); nl++) { + for (int j = 0; j < (LEN_1D/2); j++) { + for (int i = 0; i < m; i++) { + a[i] += b[i+m-j-1] * c[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c new file mode 100644 index 00000000000..22d298925af --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2101 (void) +{ +// diagonals +// main diagonal calculation +// jump in data access + + + for (int nl = 0; nl < 10*iterations; nl++) { + for (int i = 0; i < LEN_2D; i++) { + aa[i][i] += bb[i][i] * cc[i][i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c new file mode 100644 index 00000000000..6d243b3b389 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2102 (void) +{ +// diagonals +// identity matrix, best results vectorize both inner and outer loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[j][i] = (real_t)0.; + } + aa[i][i] = (real_t)1.; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c new file mode 100644 index 00000000000..51724c75688 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s211 (void) +{ +// statement reordering +// statement reordering allows vectorization + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D-1; i++) { + a[i] = b[i - 1] + c[i] * d[i]; + b[i] = b[i + 1] - e[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c new file mode 100644 index 00000000000..296087c84f9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2111 (void) +{ +// wavefronts, it will make jump in data access + + + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + for (int j = 1; j < LEN_2D; j++) { + for (int i = 1; i < LEN_2D; i++) { + aa[j][i] = (aa[j][i-1] + aa[j-1][i])/1.9; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c new file mode 100644 index 00000000000..54f54860527 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s212 (void) +{ +// statement reordering +// dependency needing temporary + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] *= c[i]; + b[i] += a[i + 1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c new file mode 100644 index 00000000000..04cc2cc3e18 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s221 (void) +{ +// loop distribution +// loop that is partially recursive + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] += c[i] * d[i]; + b[i] = b[i - 1] + a[i] + d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c new file mode 100644 index 00000000000..9c9e78ea154 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s222 (void) +{ +// loop distribution +// partial loop vectorizatio recurrence in middle + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] += b[i] * c[i]; + e[i] = e[i - 1] * e[i - 1]; + a[i] -= b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c new file mode 100644 index 00000000000..84ae8480476 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2233 (void) +{ +// loop interchange +// interchanging with one of two inner loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + cc[j][i]; + } + for (int j = 1; j < LEN_2D; j++) { + bb[i][j] = bb[i-1][j] + cc[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c new file mode 100644 index 00000000000..4c3ade37a1d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2244 (void) +{ +// node splitting +// cycle with ture and anti dependency + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i+1] = b[i] + e[i]; + a[i] = b[i] + c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c new file mode 100644 index 00000000000..90de76781a4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2251 (void) +{ +// scalar and array expansion +// scalar expansion + + + for (int nl = 0; nl < iterations; nl++) { + real_t s = (real_t)0.0; + for (int i = 0; i < LEN_1D; i++) { + a[i] = s*e[i]; + s = b[i]+c[i]; + b[i] = a[i]+d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c new file mode 100644 index 00000000000..31ae6a96d14 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2275 (void) +{ +// loop distribution is needed to be able to interchange + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[j][i] = aa[j][i] + bb[j][i] * cc[j][i]; + } + a[i] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c new file mode 100644 index 00000000000..9e8aaf540ff --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s231 (void) +{ +// loop interchange +// loop with data dependency + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; ++i) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j - 1][i] + bb[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c new file mode 100644 index 00000000000..8afb833eb81 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s232 (void) +{ +// loop interchange +// interchanging of triangular loops + + + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + for (int j = 1; j < LEN_2D; j++) { + for (int i = 1; i <= j; i++) { + aa[j][i] = aa[j][i-1]*aa[j][i-1]+bb[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c new file mode 100644 index 00000000000..ce4f3af14fb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s233 (void) +{ +// loop interchange +// interchanging with one of two inner loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + cc[j][i]; + } + for (int j = 1; j < LEN_2D; j++) { + bb[j][i] = bb[j][i-1] + cc[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c new file mode 100644 index 00000000000..32167370462 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s235 (void) +{ +// loop interchanging +// imperfectly nested loops + + + for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + a[i] += b[i] * c[i]; + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + bb[j][i] * a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c new file mode 100644 index 00000000000..76b99267c5d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s241 (void) +{ +// node splitting +// preloading necessary to allow vectorization + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = b[i] * c[i ] * d[i]; + b[i] = a[i] * a[i+1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c new file mode 100644 index 00000000000..3653ac1ed21 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{real_t a;real_t b;}; + +void s242 (struct arg *x) +{ +// node splitting + + real_t s1 = x->a; + real_t s2 = x->b; + + + for (int nl = 0; nl < iterations/5; nl++) { + for (int i = 1; i < LEN_1D; ++i) { + a[i] = a[i - 1] + s1 + s2 + b[i] + c[i] + d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c new file mode 100644 index 00000000000..a4afefc5ffe --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s243 (void) +{ +// node splitting +// false dependence cycle breaking + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = b[i] + c[i ] * d[i]; + b[i] = a[i] + d[i ] * e[i]; + a[i] = b[i] + a[i+1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c new file mode 100644 index 00000000000..b4a59001c9d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s244 (void) +{ +// node splitting +// false dependence cycle breaking + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; ++i) { + a[i] = b[i] + c[i] * d[i]; + b[i] = c[i] + b[i]; + a[i+1] = b[i] + a[i+1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c new file mode 100644 index 00000000000..ed8db917e00 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s251 (void) +{ +// scalar and array expansion +// scalar expansion + + + real_t s; + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + s = b[i] + c[i] * d[i]; + a[i] = s * s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c new file mode 100644 index 00000000000..9f0df999701 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s252 (void) +{ +// scalar and array expansion +// loop with ambiguous scalar temporary + + + real_t t, s; + for (int nl = 0; nl < iterations; nl++) { + t = (real_t) 0.; + for (int i = 0; i < LEN_1D; i++) { + s = b[i] * c[i]; + a[i] = s + t; + t = s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c new file mode 100644 index 00000000000..31416f05571 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s253 (void) +{ +// scalar and array expansion +// scalar expansio assigned under if + + + real_t s; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > b[i]) { + s = a[i] - b[i] * d[i]; + c[i] += s; + a[i] = s; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c new file mode 100644 index 00000000000..d38063e7f12 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s254 (void) +{ +// scalar and array expansion +// carry around variable + + + real_t x; + for (int nl = 0; nl < 4*iterations; nl++) { + x = b[LEN_1D-1]; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + x) * (real_t).5; + x = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c new file mode 100644 index 00000000000..0762eb202a2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s255 (void) +{ +// scalar and array expansion +// carry around variables, 2 levels + + + real_t x, y; + for (int nl = 0; nl < iterations; nl++) { + x = b[LEN_1D-1]; + y = b[LEN_1D-2]; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + x + y) * (real_t).333; + y = x; + x = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c new file mode 100644 index 00000000000..95436e79bd4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s256 (void) +{ +// scalar and array expansion +// array expansion + + + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + a[j] = (real_t)1.0 - a[j - 1]; + aa[j][i] = a[j] + bb[j][i]*d[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c new file mode 100644 index 00000000000..c794b7681e7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s257 (void) +{ +// scalar and array expansion +// array expansion + + + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + a[i] = aa[j][i] - a[i-1]; + aa[j][i] = a[i] + bb[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c new file mode 100644 index 00000000000..5d6983b3811 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s258 (void) +{ +// scalar and array expansion +// wrap-around scalar under an if + + + real_t s; + for (int nl = 0; nl < iterations; nl++) { + s = 0.; + for (int i = 0; i < LEN_2D; ++i) { + if (a[i] > 0.) { + s = d[i] * d[i]; + } + b[i] = s * c[i] + d[i]; + e[i] = (s + (real_t)1.) * aa[0][i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c new file mode 100644 index 00000000000..0ad6328c70a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s261 (void) +{ +// scalar and array expansion +// wrap-around scalar under an if + + + real_t t; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D; ++i) { + t = a[i] + b[i]; + a[i] = t + c[i-1]; + t = c[i] * d[i]; + c[i] = t; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c new file mode 100644 index 00000000000..fc685cc79b1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s271 (void) +{ +// control flow +// loop with singularity handling + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + a[i] += b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c new file mode 100644 index 00000000000..664427cccd9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c @@ -0,0 +1,35 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2710 (int x) +{ +// control flow +// scalar and vector ifs + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > b[i]) { + a[i] += b[i] * d[i]; + if (LEN_1D > 10) { + c[i] += d[i] * d[i]; + } else { + c[i] = d[i] * e[i] + (real_t)1.; + } + } else { + b[i] = a[i] + e[i] * e[i]; + if (x > (real_t)0.) { + c[i] = a[i] + d[i] * d[i]; + } else { + c[i] += e[i] * e[i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c new file mode 100644 index 00000000000..a16a6e4dae9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2711 (void) +{ +// control flow +// semantic if removal + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (b[i] != (real_t)0.0) { + a[i] += b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c new file mode 100644 index 00000000000..138b1e9ca5b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2712 (void) +{ +// control flow +// if to elemental min + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > b[i]) { + a[i] += b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c new file mode 100644 index 00000000000..19d3e8066da --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s272 (int t) +{ +// control flow +// loop with independent conditional + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (e[i] >= t) { + a[i] += c[i] * d[i]; + b[i] += c[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c new file mode 100644 index 00000000000..7757620810f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s273 (void) +{ +// control flow +// simple loop with dependent conditional + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += d[i] * e[i]; + if (a[i] < (real_t)0.) + b[i] += d[i] * e[i]; + c[i] += a[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c new file mode 100644 index 00000000000..989349b916b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s274 (void) +{ +// control flow +// complex loop with dependent conditional + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = c[i] + e[i] * d[i]; + if (a[i] > (real_t)0.) { + b[i] = a[i] + b[i]; + } else { + a[i] = d[i] * e[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c new file mode 100644 index 00000000000..8c247fe4e34 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s275 (void) +{ +// control flow +// if around inner loop, interchanging needed + + + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + if (aa[0][i] > (real_t)0.) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + bb[j][i] * cc[j][i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c new file mode 100644 index 00000000000..ffa9d356115 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s276 (void) +{ +// control flow +// if test using loop index + + + int mid = (LEN_1D/2); + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (i+1 < mid) { + a[i] += b[i] * c[i]; + } else { + a[i] += b[i] * d[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c new file mode 100644 index 00000000000..02756c9f97c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c @@ -0,0 +1,32 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s277 (void) +{ +// control flow +// test for dependences arising from guard variable computation. + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + if (a[i] >= (real_t)0.) { + goto L20; + } + if (b[i] >= (real_t)0.) { + goto L30; + } + a[i] += c[i] * d[i]; +L30: + b[i+1] = c[i] + d[i] * e[i]; +L20: +; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c new file mode 100644 index 00000000000..9527e3a8cbc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c @@ -0,0 +1,30 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s278 (void) +{ +// control flow +// if/goto to block if-then-else + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + goto L20; + } + b[i] = -b[i] + d[i] * e[i]; + goto L30; +L20: + c[i] = -c[i] + d[i] * e[i]; +L30: + a[i] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c new file mode 100644 index 00000000000..fb25252e51f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c @@ -0,0 +1,34 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s279 (void) +{ +// control flow +// vector if/gotos + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + goto L20; + } + b[i] = -b[i] + d[i] * d[i]; + if (b[i] <= a[i]) { + goto L30; + } + c[i] += d[i] * e[i]; + goto L30; +L20: + c[i] = -c[i] + e[i] * e[i]; +L30: + a[i] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c new file mode 100644 index 00000000000..72f7b539512 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s281 (void) +{ +// crossing thresholds +// index set splitting +// reverse data access + + + real_t x; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + x = a[LEN_1D-i-1] + b[i] * c[i]; + a[i] = x-(real_t)1.0; + b[i] = x; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c new file mode 100644 index 00000000000..7429ca6c0ed --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s291 (void) +{ +// loop peeling +// wrap around variable, 1 level + + + int im1; + for (int nl = 0; nl < 2*iterations; nl++) { + im1 = LEN_1D-1; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + b[im1]) * (real_t).5; + im1 = i; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c new file mode 100644 index 00000000000..8f8547477f7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s292 (void) +{ +// loop peeling +// wrap around variable, 2 levels +// similar to S291 + + + int im1, im2; + for (int nl = 0; nl < iterations; nl++) { + im1 = LEN_1D-1; + im2 = LEN_1D-2; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + b[im1] + b[im2]) * (real_t).333; + im2 = im1; + im1 = i; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c new file mode 100644 index 00000000000..0f735ddb331 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s293 (void) +{ +// loop peeling +// a(i)=a(0) with actual dependence cycle, loop is vectorizable + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[0]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c new file mode 100644 index 00000000000..deebb79a511 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s311 (void) +{ +// reductions +// sum reduction + + + real_t sum; + for (int nl = 0; nl < iterations*10; nl++) { + sum = (real_t)0.; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c new file mode 100644 index 00000000000..f4792983a01 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c @@ -0,0 +1,35 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3110 (void) +{ +// reductions +// if to max with index reductio 2 dimensions +// similar to S315 + + + int xindex, yindex; + real_t max, chksum; + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + max = aa[(0)][0]; + xindex = 0; + yindex = 0; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + if (aa[i][j] > max) { + max = aa[i][j]; + xindex = i; + yindex = j; + } + } + } + chksum = max + (real_t) xindex + (real_t) yindex; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c new file mode 100644 index 00000000000..6bb681865c2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3111 (void) +{ +// reductions +// conditional sum reduction + + + real_t sum; + for (int nl = 0; nl < iterations/2; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + sum += a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c new file mode 100644 index 00000000000..a4b39772b60 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c @@ -0,0 +1,38 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t test(real_t* A){ + real_t s = (real_t)0.0; + for (int i = 0; i < 4; i++) + s += A[i]; + return s; +} + +void s31111 (void) +{ +// reductions +// sum reduction + + + real_t sum; + for (int nl = 0; nl < 2000*iterations; nl++) { + sum = (real_t)0.; + sum += test(a); + sum += test(&a[4]); + sum += test(&a[8]); + sum += test(&a[12]); + sum += test(&a[16]); + sum += test(&a[20]); + sum += test(&a[24]); + sum += test(&a[28]); + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c new file mode 100644 index 00000000000..06dd189781d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3112 (void) +{ +// reductions +// sum reduction saving running sums + + + real_t sum; + for (int nl = 0; nl < iterations; nl++) { + sum = (real_t)0.0; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i]; + b[i] = sum; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c new file mode 100644 index 00000000000..7c7ba129d64 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3113 (void) +{ +// reductions +// maximum of absolute value + + + real_t max; + for (int nl = 0; nl < iterations*4; nl++) { + max = ABS(a[0]); + for (int i = 0; i < LEN_1D; i++) { + if ((ABS(a[i])) > max) { + max = ABS(a[i]); + } + } + dummy(a, b, c, d, e, aa, bb, cc, max); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c new file mode 100644 index 00000000000..a031d285a85 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s312 (void) +{ +// reductions +// product reduction + + + real_t prod; + for (int nl = 0; nl < 10*iterations; nl++) { + prod = (real_t)1.; + for (int i = 0; i < LEN_1D; i++) { + prod *= a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, prod); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c new file mode 100644 index 00000000000..72c2bbfd18f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s313 (void) +{ +// reductions +// dot product + + + real_t dot; + for (int nl = 0; nl < iterations*5; nl++) { + dot = (real_t)0.; + for (int i = 0; i < LEN_1D; i++) { + dot += a[i] * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, dot); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c new file mode 100644 index 00000000000..591cc312565 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s314 (void) +{ +// reductions +// if to max reduction + + + real_t x; + for (int nl = 0; nl < iterations*5; nl++) { + x = a[0]; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > x) { + x = a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, x); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c new file mode 100644 index 00000000000..e23cef08be3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c @@ -0,0 +1,34 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s315 (void) +{ +// reductions +// if to max with index reductio 1 dimension + + + for (int i = 0; i < LEN_1D; i++) + a[i] = (i * 7) % LEN_1D; + + real_t x, chksum; + int index; + for (int nl = 0; nl < iterations; nl++) { + x = a[0]; + index = 0; + for (int i = 0; i < LEN_1D; ++i) { + if (a[i] > x) { + x = a[i]; + index = i; + } + } + chksum = x + (real_t) index; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c new file mode 100644 index 00000000000..72a307a719b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s316 (void) +{ +// reductions +// if to min reduction + + + real_t x; + for (int nl = 0; nl < iterations*5; nl++) { + x = a[0]; + for (int i = 1; i < LEN_1D; ++i) { + if (a[i] < x) { + x = a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, x); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c new file mode 100644 index 00000000000..61b575aff26 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s317 (void) +{ +// reductions +// product reductio vectorize with +// 1. scalar expansion of factor, and product reduction +// 2. closed form solution: q = factor**n + + + real_t q; + for (int nl = 0; nl < 5*iterations; nl++) { + q = (real_t)1.; + for (int i = 0; i < LEN_1D/2; i++) { + q *= (real_t).99; + } + dummy(a, b, c, d, e, aa, bb, cc, q); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c new file mode 100644 index 00000000000..57327970a24 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c @@ -0,0 +1,34 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s318 (int inc) +{ +// reductions +// isamax, max absolute value, increments not equal to 1 + + int k, index; + real_t max, chksum; + for (int nl = 0; nl < iterations/2; nl++) { + k = 0; + index = 0; + max = ABS(a[0]); + k += inc; + for (int i = 1; i < LEN_1D; i++) { + if (ABS(a[k]) <= max) { + goto L5; + } + index = i; + max = ABS(a[k]); +L5: + k += inc; + } + chksum = max + (real_t) index; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c new file mode 100644 index 00000000000..4dbd5a88f15 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s319 (void) +{ +// reductions +// coupled reductions + + + real_t sum; + for (int nl = 0; nl < 2*iterations; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + a[i] = c[i] + d[i]; + sum += a[i]; + b[i] = c[i] + e[i]; + sum += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c new file mode 100644 index 00000000000..a17ac96e334 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s321 (void) +{ +// recurrences +// first order linear recurrence + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] += a[i-1] * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c new file mode 100644 index 00000000000..a82e6b1a9f0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s322 (void) +{ +// recurrences +// second order linear recurrence + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 2; i < LEN_1D; i++) { + a[i] = a[i] + a[i - 1] * b[i] + a[i - 2] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c new file mode 100644 index 00000000000..84ef82e877e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s323 (void) +{ +// recurrences +// coupled recurrence + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] = b[i-1] + c[i] * d[i]; + b[i] = a[i] + c[i] * e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c new file mode 100644 index 00000000000..ba5de42d0da --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3251 (void) +{ +// scalar and array expansion +// scalar expansion + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++){ + a[i+1] = b[i]+c[i]; + b[i] = c[i]*e[i]; + d[i] = a[i]*e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c new file mode 100644 index 00000000000..be0757713e1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c @@ -0,0 +1,29 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s331 (void) +{ +// search loops +// if to last-1 + + + int j; + real_t chksum; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] < (real_t)0.) { + j = i; + } + } + chksum = (real_t) j; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c new file mode 100644 index 00000000000..1bfcd5fed7b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c @@ -0,0 +1,32 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s332 (int t) +{ +// search loops +// first value greater than threshold + + int index; + real_t value; + real_t chksum; + for (int nl = 0; nl < iterations; nl++) { + index = -2; + value = -1.; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > t) { + index = i; + value = a[i]; + goto L20; + } + } +L20: + chksum = value + (real_t) index; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c new file mode 100644 index 00000000000..d64bfebf6a1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s341 (void) +{ +// packing +// pack positive values +// not vectorizable, value of j in unknown at each iteration + + + int j; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + j++; + a[j] = b[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c new file mode 100644 index 00000000000..883177d37c6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s342 (void) +{ +// packing +// unpacking +// not vectorizable, value of j in unknown at each iteration + + + int j = 0; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + j++; + a[i] = b[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c new file mode 100644 index 00000000000..6300856ea3a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c @@ -0,0 +1,30 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s343 (void) +{ +// packing +// pack 2-d array into one dimension +// not vectorizable, value of k in unknown at each iteration + + + int k; + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + k = -1; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + if (bb[j][i] > (real_t)0.) { + k++; + flat_2d_array[k] = aa[j][i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c new file mode 100644 index 00000000000..bfe7cee9989 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s351 (void) +{ +// loop rerolling +// unrolled saxpy + + + real_t alpha = c[0]; + for (int nl = 0; nl < 8*iterations; nl++) { + for (int i = 0; i < LEN_1D; i += 5) { + a[i] += alpha * b[i]; + a[i + 1] += alpha * b[i + 1]; + a[i + 2] += alpha * b[i + 2]; + a[i + 3] += alpha * b[i + 3]; + a[i + 4] += alpha * b[i + 4]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c new file mode 100644 index 00000000000..28e5d5000c3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s352 (void) +{ +// loop rerolling +// unrolled dot product + + + real_t dot; + for (int nl = 0; nl < 8*iterations; nl++) { + dot = (real_t)0.; + for (int i = 0; i < LEN_1D; i += 5) { + dot = dot + a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2] + * b[i + 2] + a[i + 3] * b[i + 3] + a[i + 4] * b[i + 4]; + } + dummy(a, b, c, d, e, aa, bb, cc, dot); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c new file mode 100644 index 00000000000..1adb9bf5bab --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s353 (int * __restrict__ ip) +{ +// loop rerolling +// unrolled sparse saxpy +// gather is required + + real_t alpha = c[0]; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i += 5) { + a[i] += alpha * b[ip[i]]; + a[i + 1] += alpha * b[ip[i + 1]]; + a[i + 2] += alpha * b[ip[i + 2]]; + a[i + 3] += alpha * b[ip[i + 3]]; + a[i + 4] += alpha * b[ip[i + 4]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c new file mode 100644 index 00000000000..10197f751d7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c @@ -0,0 +1,30 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int * __restrict__ a;real_t b;}; + +void s4112 (struct arg *x) +{ +// indirect addressing +// sparse saxpy +// gather is required + + int * __restrict__ ip = x->a; + real_t s = x->b; + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[ip[i]] * s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c new file mode 100644 index 00000000000..49bbe22b474 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s4113 (int * __restrict__ ip) +{ +// indirect addressing +// indirect addressing on rhs and lhs +// gather and scatter is required + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[ip[i]] = b[ip[i]] + c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c new file mode 100644 index 00000000000..d036ffcdce3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c @@ -0,0 +1,33 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int * __restrict__ a;int b;}; + +void s4114 (struct arg *x) +{ +// indirect addressing +// mix indirect addressing with variable lower and upper bounds +// gather is required + + int * __restrict__ ip = x->a; + int n1 = x->b; + + + int k; + for (int nl = 0; nl < iterations; nl++) { + for (int i = n1-1; i < LEN_1D; i++) { + k = ip[i]; + a[i] = b[i] + c[LEN_1D-k+1-2] * d[i]; + k += 5; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c new file mode 100644 index 00000000000..871fd1b8dd3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s4115 (int * __restrict__ ip) +{ +// indirect addressing +// sparse dot product +// gather is required + + real_t sum; + for (int nl = 0; nl < iterations; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i] * b[ip[i]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c new file mode 100644 index 00000000000..8c6ac7edc35 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c @@ -0,0 +1,33 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int * __restrict__ a;int b;int c;}; + +void s4116 (struct arg *x) +{ +// indirect addressing +// more complicated sparse sdot +// gather is required + + int * __restrict__ ip = x->a; + int j = x->b; + int inc = x->c; + + + real_t sum; + int off; + for (int nl = 0; nl < 100*iterations; nl++) { + sum = 0.; + for (int i = 0; i < LEN_2D-1; i++) { + off = inc + i; + sum += a[off] * aa[j-1][ip[i]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c new file mode 100644 index 00000000000..6b220f31d6c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s4117 (void) +{ +// indirect addressing +// seq function + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i] + c[i/2] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c new file mode 100644 index 00000000000..999f78adf2f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t f(real_t a, real_t b){ + return a*b; +} + +void s4121 (void) +{ +// statement functions +// elementwise multiplication + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += f(b[i],c[i]); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c new file mode 100644 index 00000000000..eaa502699d4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s421 (void) +{ +// storage classes and equivalencing +// equivalence- no overlap + + + xx = flat_2d_array; + + for (int nl = 0; nl < 4*iterations; nl++) { + yy = xx; + for (int i = 0; i < LEN_1D - 1; i++) { + xx[i] = yy[i+1] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c new file mode 100644 index 00000000000..63b9104ff8b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c @@ -0,0 +1,26 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s422 (void) +{ +// storage classes and equivalencing +// common and equivalence statement +// anti-dependence, threshold of 4 + + + xx = flat_2d_array + 4; + + for (int nl = 0; nl < 8*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + xx[i] = flat_2d_array[i + 8] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c new file mode 100644 index 00000000000..75eb4359382 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s423 (void) +{ +// storage classes and equivalencing +// common and equivalenced variables - with anti-dependence + + // do this again here + int vl = 64; + xx = flat_2d_array + vl; + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D - 1; i++) { + flat_2d_array[i+1] = xx[i] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c new file mode 100644 index 00000000000..145a2af9ede --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s424 (void) +{ +// storage classes and equivalencing +// common and equivalenced variables - overlap +// vectorizeable in strips of 64 or less + + // do this again here + int vl = 63; + xx = flat_2d_array + vl; + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D - 1; i++) { + xx[i+1] = flat_2d_array[i] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c new file mode 100644 index 00000000000..4f2597aff8f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c @@ -0,0 +1,27 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s431 (void) +{ +// parameters +// parameter statement + + int k1=1; + int k2=2; + int k=2*k1-k2; + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[i+k] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c new file mode 100644 index 00000000000..7f7ab226fcd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c @@ -0,0 +1,28 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s441 (void) +{ +// non-logical if's +// arithmetic if + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (d[i] < (real_t)0.) { + a[i] += b[i] * c[i]; + } else if (d[i] == (real_t)0.) { + a[i] += b[i] * b[i]; + } else { + a[i] += c[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c new file mode 100644 index 00000000000..1c459e05151 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s442 (void) +{ +// non-logical if's +// computed goto + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D; i++) { + switch (indx[i]) { + case 1: goto L15; + case 2: goto L20; + case 3: goto L30; + case 4: goto L40; + } +L15: + a[i] += b[i] * b[i]; + goto L50; +L20: + a[i] += c[i] * c[i]; + goto L50; +L30: + a[i] += d[i] * d[i]; + goto L50; +L40: + a[i] += e[i] * e[i]; +L50: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c new file mode 100644 index 00000000000..a8623f9119a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c @@ -0,0 +1,33 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s443 (void) +{ +// non-logical if's +// arithmetic if + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (d[i] <= (real_t)0.) { + goto L20; + } else { + goto L30; + } +L20: + a[i] += b[i] * c[i]; + goto L50; +L30: + a[i] += b[i] * b[i]; +L50: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c new file mode 100644 index 00000000000..3b13b2c7e13 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s451 (void) +{ +// intrinsic functions +// intrinsics + + + for (int nl = 0; nl < iterations/5; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = sinf(b[i]) + cosf(c[i]); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c new file mode 100644 index 00000000000..7e0dc2190d6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s452 (void) +{ +// intrinsic functions +// seq function + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i] + c[i] * (real_t) (i+1); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c new file mode 100644 index 00000000000..c0115ce3753 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s453 (void) +{ +// induction varibale recognition + + real_t s; + + + for (int nl = 0; nl < iterations*2; nl++) { + s = 0.; + for (int i = 0; i < LEN_1D; i++) { + s += (real_t)2.; + a[i] = s * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c new file mode 100644 index 00000000000..5de316738f9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c @@ -0,0 +1,33 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +int s471s(void) +{ +// -- dummy subroutine call made in s471 + return 0; +} + +void s471 (void) +{ +// call statements + + int m = LEN_1D; + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < m; i++) { + x[i] = b[i] + d[i] * d[i]; + s471s(); + b[i] = c[i] + d[i] * e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c new file mode 100644 index 00000000000..6ad8272aeb2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s481 (void) +{ +// non-local goto's +// stop statement + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (d[i] < (real_t)0.) { + exit (0); + } + a[i] += b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c new file mode 100644 index 00000000000..bba5f744453 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s482 (void) +{ +// non-local goto's +// other loop exit with code before exit + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] * c[i]; + if (c[i] > b[i]) break; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c new file mode 100644 index 00000000000..546ba056955 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s491 (int * __restrict__ ip) +{ +// vector semantics +// indirect addressing on lhs, store in sequence +// scatter is required + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[ip[i]] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c new file mode 100644 index 00000000000..6cce1d173cf --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void va (void) +{ +// control loops +// vector assignment + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c new file mode 100644 index 00000000000..9d994cad60a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vag (int * __restrict__ ip) +{ +// control loops +// vector assignment, gather +// gather is required + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[ip[i]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c new file mode 100644 index 00000000000..104e587ec14 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c @@ -0,0 +1,22 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vas (int * __restrict__ ip) +{ +// control loops +// vector assignment, scatter +// scatter is required + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[ip[i]] = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c new file mode 100644 index 00000000000..8455c94ce37 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c @@ -0,0 +1,38 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vbor (void) +{ +// control loops +// basic operations rates, isolate arithmetic from memory traffic +// all combinations of three, 59 flops for 6 loads and 1 store. + + + real_t a1, b1, c1, d1, e1, f1; + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_2D; i++) { + a1 = a[i]; + b1 = b[i]; + c1 = c[i]; + d1 = d[i]; + e1 = e[i]; + f1 = aa[0][i]; + a1 = a1 * b1 * c1 + a1 * b1 * d1 + a1 * b1 * e1 + a1 * b1 * f1 + + a1 * c1 * d1 + a1 * c1 * e1 + a1 * c1 * f1 + a1 * d1 * e1 + + a1 * d1 * f1 + a1 * e1 * f1; + b1 = b1 * c1 * d1 + b1 * c1 * e1 + b1 * c1 * f1 + b1 * d1 * e1 + + b1 * d1 * f1 + b1 * e1 * f1; + c1 = c1 * d1 * e1 + c1 * d1 * f1 + c1 * e1 * f1; + d1 = d1 * e1 * f1; + x[i] = a1 * b1 * c1 * d1; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c new file mode 100644 index 00000000000..56adc5180c2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vdotr (void) +{ +// control loops +// vector dot product reduction + + + real_t dot; + for (int nl = 0; nl < iterations*10; nl++) { + dot = 0.; + for (int i = 0; i < LEN_1D; i++) { + dot += a[i] * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, dot); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c new file mode 100644 index 00000000000..c3830822cae --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c @@ -0,0 +1,24 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vif (void) +{ +// control loops +// vector if + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + a[i] = b[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c new file mode 100644 index 00000000000..68d3025f536 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpv (void) +{ +// control loops +// vector plus vector + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c new file mode 100644 index 00000000000..652e0424d01 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpvpv (void) +{ +// control loops +// vector plus vector plus vector + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] + c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c new file mode 100644 index 00000000000..9531fd1df3c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpvts (real_t s) +{ +// control loops +// vector plus vector times scalar + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] * s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c new file mode 100644 index 00000000000..3ab6b836a8e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpvtv (void) +{ +// control loops +// vector plus vector times vector + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c new file mode 100644 index 00000000000..73c644abcd6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c @@ -0,0 +1,25 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vsumr (void) +{ +// control loops +// vector sum reduction + + + real_t sum; + for (int nl = 0; nl < iterations*10; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c new file mode 100644 index 00000000000..24bdfa55522 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vtv (void) +{ +// control loops +// vector times vector + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] *= b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c new file mode 100644 index 00000000000..39dfbb98d1a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c @@ -0,0 +1,23 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vtvtv (void) +{ +// control loops +// vector times vector times vector + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[i] * b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file