From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1851) id 3DE753858026; Tue, 26 Oct 2021 15:24:33 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 3DE753858026 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Martin Liska To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/marxin/heads/TSVC-v2)] Add TSVC tests. X-Act-Checkin: gcc X-Git-Author: Martin Liska X-Git-Refname: refs/users/marxin/heads/TSVC-v2 X-Git-Oldrev: 4e417eea8f3f14131f7370f9bd5dd568611d11df X-Git-Newrev: 304055849287a6ba68b88a02ed49099fe3d8fb22 Message-Id: <20211026152433.3DE753858026@sourceware.org> Date: Tue, 26 Oct 2021 15:24:33 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 26 Oct 2021 15:24:33 -0000 https://gcc.gnu.org/g:304055849287a6ba68b88a02ed49099fe3d8fb22 commit 304055849287a6ba68b88a02ed49099fe3d8fb22 Author: Martin Liska Date: Fri Oct 15 18:31:48 2021 +0200 Add TSVC tests. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect.exp: Include also tsvc sub-directory. * gcc.dg/vect/tsvc/license.txt: New test. * gcc.dg/vect/tsvc/tsvc.h: New test. * gcc.dg/vect/tsvc/vect-tsvc-s000.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s111.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1111.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1112.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1113.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1115.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1119.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s112.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s113.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s114.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s115.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s116.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1161.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s118.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s119.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s121.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1213.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s122.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1221.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s123.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1232.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s124.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1244.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s125.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1251.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s126.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s127.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1279.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s128.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1281.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s131.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s13110.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s132.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1351.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s141.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s1421.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s151.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s152.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s161.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s162.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s171.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s172.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s173.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s174.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s175.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s176.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2101.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2102.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s211.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2111.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s212.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s221.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s222.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2233.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2244.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2251.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2275.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s231.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s232.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s233.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s235.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s241.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s242.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s243.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s244.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s251.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s252.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s253.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s254.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s255.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s256.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s257.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s258.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s261.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s271.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2710.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2711.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s2712.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s272.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s273.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s274.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s275.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s276.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s277.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s278.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s279.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s281.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s291.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s292.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s293.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s311.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s3110.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s3111.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s31111.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s3112.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s3113.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s312.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s313.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s314.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s315.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s316.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s317.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s318.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s319.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s321.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s322.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s323.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s3251.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s331.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s332.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s341.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s342.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s343.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s351.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s352.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s353.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4112.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4113.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4114.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4115.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4116.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4117.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s4121.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s421.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s422.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s423.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s424.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s431.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s441.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s442.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s443.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s451.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s452.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s453.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s471.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s481.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s482.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-s491.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-va.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vag.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vas.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vbor.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vdotr.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vif.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vpv.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vpvpv.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vpvts.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vpvtv.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vsumr.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vtv.c: New test. * gcc.dg/vect/tsvc/vect-tsvc-vtvtv.c: New test. Diff: --- gcc/testsuite/gcc.dg/vect/tsvc/license.txt | 29 + gcc/testsuite/gcc.dg/vect/tsvc/tsvc.h | 1421 +++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s000.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s111.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1111.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1112.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1113.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1115.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1119.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s112.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s113.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s114.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s115.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s116.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1161.c | 48 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s118.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s119.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s121.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1213.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s122.c | 48 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1221.c | 38 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s123.c | 47 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1232.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s124.c | 47 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1244.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s125.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1251.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s126.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s127.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1279.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s128.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1281.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s131.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s13110.c | 51 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s132.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1351.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s141.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1421.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s151.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s152.c | 46 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s161.c | 48 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s162.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s171.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s172.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s173.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s174.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s175.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s176.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2101.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2102.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s211.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2111.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s212.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s221.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s222.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2233.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2244.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2251.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2275.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s231.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s232.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s233.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s235.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s241.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s242.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s243.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s244.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s251.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s252.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s253.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s254.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s255.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s256.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s257.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s258.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s261.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s271.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2710.c | 55 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2711.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2712.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s272.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s273.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s274.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s275.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s276.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s277.c | 49 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s278.c | 47 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s279.c | 51 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s281.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s291.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s292.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s293.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s311.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3110.c | 52 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3111.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s31111.c | 54 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3112.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3113.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s312.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s313.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s314.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s315.c | 50 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s316.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s317.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s318.c | 54 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s319.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s321.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s322.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s323.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3251.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s331.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s332.c | 52 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s341.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s342.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s343.c | 47 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s351.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s352.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s353.c | 47 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4112.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4113.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4114.c | 47 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4115.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4116.c | 49 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4117.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4121.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s421.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s422.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s423.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s424.c | 44 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s431.c | 43 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s441.c | 45 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s442.c | 57 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s443.c | 50 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s451.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s452.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s453.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s471.c | 49 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s481.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s482.c | 40 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s491.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-va.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vag.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vas.c | 42 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vbor.c | 54 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vdotr.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vif.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpv.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvpv.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvts.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvtv.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vsumr.c | 41 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vtv.c | 39 + gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vtvtv.c | 39 + gcc/testsuite/gcc.dg/vect/vect.exp | 3 + 154 files changed, 7948 insertions(+) diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/license.txt b/gcc/testsuite/gcc.dg/vect/tsvc/license.txt new file mode 100644 index 00000000000..e16b36cb15c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/license.txt @@ -0,0 +1,29 @@ +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/tsvc.h b/gcc/testsuite/gcc.dg/vect/tsvc/tsvc.h new file mode 100644 index 00000000000..b52108dae9f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/tsvc.h @@ -0,0 +1,1421 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +#define iterations 10000 +#define LEN_1D 32000 +#define LEN_2D 256 +#define ARRAY_ALIGNMENT 64 + +#pragma GCC push_options +#pragma GCC optimize "-fno-tree-vectorize" + +#include +#include +#include +#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); + +__attribute__((aligned(ARRAY_ALIGNMENT))) +real_t flat_2d_array[LEN_2D * LEN_2D]; +__attribute__((aligned(ARRAY_ALIGNMENT))) real_t x[LEN_1D]; +__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]; +__attribute__((aligned(ARRAY_ALIGNMENT))) int indx[LEN_1D]; + +real_t* __restrict__ xx; +real_t* yy; + +void set_1d_array(real_t * arr, int length, real_t value, int stride); +void set_2d_array(real_t arr[LEN_2D][LEN_2D], real_t value, int stride); + +struct args_t { + struct timeval t1; + struct timeval t2; + void * __restrict__ arg_info; +}; + +enum {SET1D_RECIP_IDX = -1, SET1D_RECIP_IDX_SQ = -2}; + +real_t sum1d(real_t arr[LEN_1D]); +real_t sum2d(real_t arr[LEN_2D][LEN_2D]); + +real_t sum_x(); +real_t sum_a(); +real_t sum_b(); +real_t sum_c(); +real_t sum_e(); + +real_t sum_half_xx(); + +real_t sum_a_aa(); + +real_t sum_aa(); +real_t sum_bb(); +real_t sum_cc(); +real_t sum_xx(); + +real_t sum_aa_bb(); + +real_t sum_flat_2d_array(); + +real_t sum1d(real_t arr[LEN_1D]){ + real_t ret = 0.; + for (int i = 0; i < LEN_1D; i++) + ret += arr[i]; + return ret; +} + +real_t sum2d(real_t arr[LEN_2D][LEN_2D]){ + real_t sum = 0.; + for (int i = 0; i < LEN_2D; i++){ + for (int j = 0; j < LEN_2D; j++){ + sum += arr[i][j]; + } + } + + return sum; +} + +real_t sum_x() +{ + return sum1d(x); +} + +real_t sum_xx() +{ + return sum1d(xx); +} + +real_t sum_a() +{ + return sum1d(a); +} + +real_t sum_b() +{ + return sum1d(b); +} + +real_t sum_a_aa() +{ + return sum1d(a) + sum2d(aa); +} + +real_t sum_c() +{ + return sum1d(c); +} + +real_t sum_e() +{ + return sum1d(e); +} + +real_t sum_aa() +{ + return sum2d(aa); +} + +real_t sum_bb() +{ + return sum2d(bb); +} + +real_t sum_aa_bb() +{ + return sum2d(aa) + sum2d(bb); +} + +real_t sum_cc() +{ + return sum2d(cc); +} + +real_t sum_half_xx() +{ + real_t temp = 00; + + for (int i = 0; i < LEN_1D/2; i++){ + temp += xx[i]; + } + + return temp; +} + +real_t sum_flat_2d_array() +{ + real_t sum = 0.; + + for (int i = 0; i < LEN_2D*LEN_2D; i++){ + sum += flat_2d_array[i]; + } + + return sum; +} + + +void set_1d_array(real_t * arr, int length, real_t value, int stride) +{ + if (stride == SET1D_RECIP_IDX) { + for (int i = 0; i < length; i++) { + arr[i] = 1. / (real_t) (i+1); + } + } else if (stride == SET1D_RECIP_IDX_SQ) { + for (int i = 0; i < length; i++) { + arr[i] = 1. / (real_t) ((i+1) * (i+1)); + } + } else { + for (int i = 0; i < length; i += stride) { + arr[i] = value; + } + } +} + +void set_2d_array(real_t arr[LEN_2D][LEN_2D], real_t value, int stride) +{ + for (int i = 0; i < LEN_2D; i++) { + set_1d_array(arr[i], LEN_2D, value, stride); + } +} + +void init(int** ip, real_t* s1, real_t* s2){ + xx = (real_t*) memalign(ARRAY_ALIGNMENT, LEN_1D*sizeof(real_t)); + *ip = (int *) memalign(ARRAY_ALIGNMENT, LEN_1D*sizeof(real_t)); + + for (int i = 0; i < LEN_1D; i = i+5){ + (*ip)[i] = (i+4); + (*ip)[i+1] = (i+2); + (*ip)[i+2] = (i); + (*ip)[i+3] = (i+3); + (*ip)[i+4] = (i+1); + } + + set_1d_array(a, LEN_1D, 1.,1); + set_1d_array(b, LEN_1D, 1.,1); + set_1d_array(c, LEN_1D, 1.,1); + set_1d_array(d, LEN_1D, 1.,1); + set_1d_array(e, LEN_1D, 1.,1); + set_1d_array(x, LEN_1D, 1.,1); + set_2d_array(aa, 0.,SET1D_RECIP_IDX); + set_2d_array(bb, 0.,SET1D_RECIP_IDX); + set_2d_array(cc, 0.,SET1D_RECIP_IDX); + + for (int i = 0; i < LEN_1D; i++) { + indx[i] = (i+1) % 4+1; + } + + *s1 = 1.0; + *s2 = 2.0; +} + +int initialise_arrays(const char* name) +{ + real_t any=0.; + real_t zero=0.; + real_t half=.5; + real_t one=1.; + real_t two=2.; + real_t small = .000001; + int unit =1; + int frac = SET1D_RECIP_IDX; + int frac2 = SET1D_RECIP_IDX_SQ; + + if (!strcmp(name, "s000")) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = 1+i; + b[i] = 2+i; + c[i] = 3+i; + d[i] = 4+i; + e[i] = 5+i; + } + } else if (!strcmp(name, "s111")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + set_1d_array(c, LEN_1D, any,frac2); + set_1d_array(d, LEN_1D, any,frac2); + set_1d_array(e, LEN_1D, any,frac2); + } else if (!strcmp(name, "s112")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s113")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s114")) { + set_2d_array(aa, any,frac); + set_2d_array(bb, any,frac2); + } else if (!strcmp(name, "s115")) { + set_1d_array(a, LEN_1D, one,unit); + set_2d_array(aa,small,unit); + set_2d_array(bb,small,unit); + set_2d_array(cc,small,unit); + } else if (!strcmp(name, "s116")) { + set_1d_array(a, LEN_1D, one,unit); + } else if (!strcmp(name, "s118")) { + set_1d_array(a, LEN_1D, one,unit); + set_2d_array(bb,small,unit); + } else if (!strcmp(name, "s119")) { + set_2d_array(aa, one,unit); + set_2d_array(bb, any,frac2); + } else if (!strcmp(name, "s121")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s122")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s123")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s124")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s125")) { + set_1d_array(flat_2d_array, LEN_2D*LEN_2D,zero,unit); + set_2d_array(aa, one,unit); + set_2d_array(bb,half,unit); + set_2d_array(cc, two,unit); + } else if (!strcmp(name, "s126")) { + set_2d_array(bb, one,unit); + set_1d_array( flat_2d_array, LEN_2D*LEN_2D,any,frac); + set_2d_array(cc, any,frac); + } else if (!strcmp(name, "s127")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s128")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, two,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, one,unit); + } else if (!strcmp(name, "s131")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s132")) { + set_2d_array(aa, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s141")) { + set_1d_array( flat_2d_array, LEN_2D*LEN_2D, one,unit); + set_2d_array(bb, any,frac2); + } else if (!strcmp(name, "s151")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s152")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D,zero,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s161")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array( &b[0], LEN_1D/2, one,2); + set_1d_array( &b[1], LEN_1D/2,-one,2); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s162")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s171")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s172")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s173")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s174")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s175")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s176")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s211")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s212")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s221")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s222")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + } else if (!strcmp(name, "s231")) { + set_2d_array(aa, one,unit); + set_2d_array(bb, any,frac2); + } else if (!strcmp(name, "s232")) { + set_2d_array(aa, one,unit); + set_2d_array(bb,zero,unit); + } else if (!strcmp(name, "s233")) { + set_2d_array(aa, any,frac); + set_2d_array(bb, any,frac); + set_2d_array(cc, any,frac); + } else if (!strcmp(name, "s234")) { + set_2d_array(aa, one,unit); + set_2d_array(bb, any,frac); + set_2d_array(cc, any,frac); + } else if (!strcmp(name, "s235")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + set_2d_array(aa, one,unit); + set_2d_array(bb, any, frac2); + } else if (!strcmp(name, "s241")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, one,unit); + } else if (!strcmp(name, "s242")) { + set_1d_array(a, LEN_1D,small,unit); + set_1d_array(b, LEN_1D,small,unit); + set_1d_array(c, LEN_1D,small,unit); + set_1d_array(d, LEN_1D,small,unit); + } else if (!strcmp(name, "s243")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s244")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D,small,unit); + set_1d_array(d, LEN_1D,small,unit); + } else if (!strcmp(name, "s251")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s252")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + } else if (!strcmp(name, "s253")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D,small,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s254")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + } else if (!strcmp(name, "s255")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + } else if (!strcmp(name, "s256")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, two,frac); + set_2d_array(aa, two,unit); + set_2d_array(bb, one,unit); + } else if (!strcmp(name, "s257")) { + set_1d_array(a, LEN_1D, one,unit); + set_2d_array(aa, two,unit); + set_2d_array(bb, one,unit); + } else if (!strcmp(name, "s258")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D,zero,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D,zero,unit); + set_2d_array(aa, any,frac); + } else if (!strcmp(name, "s261")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + set_1d_array(c, LEN_1D, any,frac2); + set_1d_array(d, LEN_1D, one,unit); + } else if (!strcmp(name, "s271")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s272")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, two,unit); + } else if (!strcmp(name, "s273")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D,small,unit); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s274")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s275")) { + set_2d_array(aa, one,unit); + set_2d_array(bb,small,unit); + set_2d_array(cc,small,unit); + } else if (!strcmp(name, "s276")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s277")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array( b, LEN_1D/2, one,unit); + set_1d_array( &b[LEN_1D/2], LEN_1D/2,-one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s278")) { + set_1d_array( a, LEN_1D/2,-one,unit); + set_1d_array( &a[LEN_1D/2], LEN_1D/2,one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s279")) { + set_1d_array( a, LEN_1D/2,-one,unit); + set_1d_array( &a[LEN_1D/2], LEN_1D/2,one,unit); +// set_1d_array(a, LEN_1D, -one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s2710")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s2711")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s2712")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s281")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + } else if (!strcmp(name, "1s281")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, one,unit); + set_1d_array(e, LEN_1D, one,unit); + set_1d_array(x, LEN_1D, one,unit); + } else if (!strcmp(name, "s291")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + } else if (!strcmp(name, "s292")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + } else if (!strcmp(name, "s293")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "s2101")) { + set_2d_array(aa, one,unit); + set_2d_array(bb, any,frac); + set_2d_array(cc, any,frac); + } else if (!strcmp(name, "s2102")) { + set_2d_array(aa,zero,unit); + } else if (!strcmp(name, "s2111")) { + set_2d_array(aa, small,unit); + } else if (!strcmp(name, "s311")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "s312")) { + set_1d_array(a, LEN_1D,1.000001,unit); + } else if (!strcmp(name, "s313")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "s314")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "s315")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "s316")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "s317")) { + } else if (!strcmp(name, "s318")) { + set_1d_array(a, LEN_1D, any,frac); + a[LEN_1D-1] = -two; + } else if (!strcmp(name, "s319")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D,zero,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s3110")) { + set_2d_array(aa, any,frac); + aa[LEN_2D-1][LEN_2D-1] = two; + } else if (!strcmp(name, "s3111")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "s3112")) { + set_1d_array(a, LEN_1D, any,frac2); + set_1d_array(b, LEN_1D,zero,unit); + } else if (!strcmp(name, "s3113")) { + set_1d_array(a, LEN_1D, any,frac); + a[LEN_1D-1] = -two; + } else if (!strcmp(name, "s321")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D,zero,unit); + } else if (!strcmp(name, "s322")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D,zero,unit); + set_1d_array(c, LEN_1D,zero,unit); + } else if (!strcmp(name, "s323")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s331")) { + set_1d_array(a, LEN_1D, any,frac); + a[LEN_1D-1] = -one; + } else if (!strcmp(name, "s332")) { + set_1d_array(a, LEN_1D, any,frac2); + a[LEN_1D-1] = two; + } else if (!strcmp(name, "s341")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "s342")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "s343")) { + set_2d_array(aa, any,frac); + set_2d_array(bb, one,unit); + } else if (!strcmp(name, "s351")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + c[0] = 1.; + } else if (!strcmp(name, "s352")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "s353")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + c[0] = 1.; + } else if (!strcmp(name, "s411")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s412")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s413")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s414")) { + set_2d_array(aa, one,unit); + set_2d_array(bb, any,frac); + set_2d_array(cc, any,frac); + } else if (!strcmp(name, "s415")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + a[LEN_1D-1] = -one; + } else if (!strcmp(name, "s421")) { + set_1d_array(a, LEN_1D, any,frac2); + set_1d_array(flat_2d_array, LEN_1D, one, unit); + } else if (!strcmp(name, "s422")) { + set_1d_array(flat_2d_array, LEN_1D,one,unit); + set_1d_array(a, LEN_1D, any,frac2); + set_1d_array(flat_2d_array + LEN_1D, LEN_1D, zero, unit); + } else if (!strcmp(name, "s1421")) { + set_1d_array(b, LEN_1D, one, unit); + } else if (!strcmp(name, "s423")) { + set_1d_array(flat_2d_array, LEN_1D,zero,unit); + set_1d_array(a, LEN_1D, any,frac2); + set_1d_array(flat_2d_array + LEN_1D, LEN_1D, one, unit); + } else if (!strcmp(name, "s424")) { + set_1d_array(flat_2d_array, LEN_1D,one,unit); + set_1d_array(a, LEN_1D, any,frac2); + set_1d_array(flat_2d_array, LEN_1D, zero, unit); + } else if (!strcmp(name, "s431")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s432")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s441")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(&d[0], LEN_1D/3 , -one,unit); + set_1d_array(&d[LEN_1D/3], LEN_1D/3 , zero,unit); + set_1d_array(&d[(2*LEN_1D/3)], LEN_1D/3+1, one,unit); + } else if (!strcmp(name, "s442")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + } else if (!strcmp(name, "s443")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s451")) { + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s452")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D,small,unit); + } else if (!strcmp(name, "s453")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "s471")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, one,unit); + set_1d_array(d, LEN_1D, any,frac); + set_1d_array(e, LEN_1D, any,frac); + set_1d_array(x, LEN_1D, zero, unit); + } else if (!strcmp(name, "s481")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s482")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "s491")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s4112")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "s4113")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac2); + } else if (!strcmp(name, "s4114")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s4115")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "s4116")) { + set_1d_array(a, LEN_1D, any,frac); + set_2d_array(aa, any,frac); + } else if (!strcmp(name, "s4117")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D, any,frac); + set_1d_array(d, LEN_1D, any,frac); + } else if (!strcmp(name, "s4121")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "va")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "vag")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "vas")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "vif")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "vpv")) { + set_1d_array(a, LEN_1D,zero,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "vtv")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, one,unit); + } else if (!strcmp(name, "vpvtv")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, any,frac); + } else if (!strcmp(name, "vpvts")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, any,frac2); + } else if (!strcmp(name, "vpvpv")) { + set_1d_array(a, LEN_1D, any,frac2); + set_1d_array(b, LEN_1D, one,unit); + set_1d_array(c, LEN_1D,-one,unit); + } else if (!strcmp(name, "vtvtv")) { + set_1d_array(a, LEN_1D, one,unit); + set_1d_array(b, LEN_1D, two,unit); + set_1d_array(c, LEN_1D,half,unit); + } else if (!strcmp(name, "vsumr")) { + set_1d_array(a, LEN_1D, any,frac); + } else if (!strcmp(name, "vdotr")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + } else if (!strcmp(name, "vbor")) { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, one,frac); + set_1d_array(d, LEN_1D, two,frac); + set_1d_array(e, LEN_1D,half,frac); + set_2d_array(aa, any,frac); + } else { + set_1d_array(a, LEN_1D, any,frac); + set_1d_array(b, LEN_1D, any,frac); + set_1d_array(c, LEN_1D, one,frac); + set_1d_array(d, LEN_1D, two,frac); + set_1d_array(e, LEN_1D,half,frac); + set_2d_array(aa, half,frac); + set_2d_array(bb, one,frac); + set_2d_array(cc, any,frac); + } + + return 0; +} + +real_t calc_checksum(const char * name) +{ + if (!strcmp(name, "s000")) { + return sum_a(); + } else if (!strcmp(name, "s111")) { + return sum_a(); + } else if (!strcmp(name, "s1111")) { + return sum_a(); + } else if (!strcmp(name, "s112")) { + return sum_a(); + } else if (!strcmp(name, "s1112")) { + return sum_a(); + } else if (!strcmp(name, "s113")) { + return sum_a(); + } else if (!strcmp(name, "s1113")) { + return sum_a(); + } else if (!strcmp(name, "s114")) { + return sum_aa(); + } else if (!strcmp(name, "s115")) { + return sum_a(); + } else if (!strcmp(name, "s1115")) { + return sum_aa(); + } else if (!strcmp(name, "s116")) { + return sum_a(); + } else if (!strcmp(name, "s118")) { + return sum_a(); + } else if (!strcmp(name, "s119")) { + return sum_aa(); + } else if (!strcmp(name, "s1119")) { + return sum_aa(); + } else if (!strcmp(name, "s121")) { + return sum_a(); + } else if (!strcmp(name, "s122")) { + return sum_a(); + } else if (!strcmp(name, "s123")) { + return sum_a(); + } else if (!strcmp(name, "s124")) { + return sum_a(); + } else if (!strcmp(name, "s125")) { + return sum_flat_2d_array(); + } else if (!strcmp(name, "s126")) { + return sum_bb(); + } else if (!strcmp(name, "s127")) { + return sum_a(); + } else if (!strcmp(name, "s128")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s131")) { + return sum_a(); + } else if (!strcmp(name, "s132")) { + return sum_aa(); + } else if (!strcmp(name, "s141")) { + return sum_flat_2d_array(); + } else if (!strcmp(name, "s151")) { + return sum_a(); + } else if (!strcmp(name, "s152")) { + return sum_a(); + } else if (!strcmp(name, "s161")) { + return sum_a() + sum_c(); + } else if (!strcmp(name, "s1161")) { + return sum_a() + sum_c(); + } else if (!strcmp(name, "s162")) { + return sum_a(); + } else if (!strcmp(name, "s171")) { + return sum_a(); + } else if (!strcmp(name, "s172")) { + return sum_a(); + } else if (!strcmp(name, "s173")) { + return sum_a(); + } else if (!strcmp(name, "s174")) { + return sum_a(); + } else if (!strcmp(name, "s175")) { + return sum_a(); + } else if (!strcmp(name, "s176")) { + return sum_a(); + } else if (!strcmp(name, "s211")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s212")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s1213")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s221")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s1221")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s222")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s231")) { + return sum_aa(); + } else if (!strcmp(name, "s232")) { + return sum_aa(); + } else if (!strcmp(name, "s1232")) { + return sum_aa(); + } else if (!strcmp(name, "s233")) { + return sum_aa_bb(); + } else if (!strcmp(name, "s2233")) { + return sum_aa_bb(); + } else if (!strcmp(name, "s235")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s241")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s242")) { + return sum_a(); + } else if (!strcmp(name, "s243")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s244")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s1244")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s2244")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s251")) { + return sum_a(); + } else if (!strcmp(name, "s1251")) { + return sum_a(); + } else if (!strcmp(name, "s2251")) { + return sum_a(); + } else if (!strcmp(name, "s3251")) { + return sum_a(); + } else if (!strcmp(name, "s252")) { + return sum_a(); + } else if (!strcmp(name, "s253")) { + return sum_a() + sum_c(); + } else if (!strcmp(name, "s254")) { + return sum_a(); + } else if (!strcmp(name, "s255")) { + return sum_a(); + } else if (!strcmp(name, "s256")) { + return sum_a_aa(); + } else if (!strcmp(name, "s257")) { + return sum_a_aa(); + } else if (!strcmp(name, "s258")) { + return sum_b() + sum_e(); + } else if (!strcmp(name, "s261")) { + return sum_a() + sum_c(); + } else if (!strcmp(name, "s271")) { + return sum_a(); + } else if (!strcmp(name, "s272")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s273")) { + return sum_a() + sum_b() + sum_c(); + } else if (!strcmp(name, "s274")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s275")) { + return sum_aa(); + } else if (!strcmp(name, "s2275")) { + return sum_aa(); + } else if (!strcmp(name, "s276")) { + return sum_a(); + } else if (!strcmp(name, "s277")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s278")) { + return sum_a() + sum_b() + sum_c(); + } else if (!strcmp(name, "s279")) { + return sum_a() + sum_b() + sum_c(); + } else if (!strcmp(name, "s1279")) { + return sum_a() + sum_b() + sum_c(); + } else if (!strcmp(name, "s2710")) { + return sum_a() + sum_b() + sum_c(); + } else if (!strcmp(name, "s2711")) { + return sum_a(); + } else if (!strcmp(name, "s2712")) { + return sum_a(); + } else if (!strcmp(name, "s281")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s1281")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s291")) { + return sum_a(); + } else if (!strcmp(name, "s292")) { + return sum_a(); + } else if (!strcmp(name, "s293")) { + return sum_a(); + } else if (!strcmp(name, "s2101")) { + return sum_aa(); + } else if (!strcmp(name, "s2102")) { + return sum_aa(); + } else if (!strcmp(name, "s2111")) { + return sum_aa(); + } else if (!strcmp(name, "s311")) { + return sum_a(); + } else if (!strcmp(name, "s31111")) { + return sum_a(); + } else if (!strcmp(name, "s321")) { + return sum_a(); + } else if (!strcmp(name, "s322")) { + return sum_a(); + } else if (!strcmp(name, "s323")) { + return sum_a() + sum_b(); + } else if (!strcmp(name, "s341")) { + return sum_a(); + } else if (!strcmp(name, "s342")) { + return sum_a(); + } else if (!strcmp(name, "s343")) { + return sum_flat_2d_array(); + } else if (!strcmp(name, "s351")) { + return sum_a(); + } else if (!strcmp(name, "s1351")) { + return sum_a(); + } else if (!strcmp(name, "s353")) { + return sum_a(); + } else if (!strcmp(name, "s421")) { + return sum_xx(); + } else if (!strcmp(name, "s1421")) { + return sum_half_xx(); + } else if (!strcmp(name, "s422")) { + return sum_xx(); + } else if (!strcmp(name, "s423")) { + return sum_flat_2d_array(); + } else if (!strcmp(name, "s424")) { + return sum_xx(); + } else if (!strcmp(name, "s431")) { + return sum_a(); + } else if (!strcmp(name, "s441")) { + return sum_a(); + } else if (!strcmp(name, "s442")) { + return sum_a(); + } else if (!strcmp(name, "s443")) { + return sum_a(); + } else if (!strcmp(name, "s451")) { + return sum_a(); + } else if (!strcmp(name, "s452")) { + return sum_a(); + } else if (!strcmp(name, "s453")) { + return sum_a(); + } else if (!strcmp(name, "s471")) { + return sum_x() + sum_b(); + } else if (!strcmp(name, "s481")) { + return sum_a(); + } else if (!strcmp(name, "s482")) { + return sum_a(); + } else if (!strcmp(name, "s491")) { + return sum_a(); + } else if (!strcmp(name, "s4112")) { + return sum_a(); + } else if (!strcmp(name, "s4113")) { + return sum_a(); + } else if (!strcmp(name, "s4114")) { + return sum_a(); + } else if (!strcmp(name, "s4117")) { + return sum_a(); + } else if (!strcmp(name, "s4121")) { + return sum_a(); + } else if (!strcmp(name, "va")) { + return sum_a(); + } else if (!strcmp(name, "vag")) { + return sum_a(); + } else if (!strcmp(name, "vas")) { + return sum_a(); + } else if (!strcmp(name, "vif")) { + return sum_a(); + } else if (!strcmp(name, "vpv")) { + return sum_a(); + } else if (!strcmp(name, "vtv")) { + return sum_a(); + } else if (!strcmp(name, "vpvtv")) { + return sum_a(); + } else if (!strcmp(name, "vpvts")) { + return sum_a(); + } else if (!strcmp(name, "vpvpv")) { + return sum_a(); + } else if (!strcmp(name, "vtvtv")) { + return sum_a(); + } else if (!strcmp(name, "vsumr")) { + return sum_a(); + } else if (!strcmp(name, "vbor")) { + return sum_x(); + } else { + fprintf(stderr, "Unknown function name passed to calc_checksum: %s\n", name); + exit(1); + } +} + +real_t get_expected_result(const char * name) +{ + if (!strcmp(name, "s000")) { + return 512075584.f; + } else if (!strcmp(name, "s111")) { + return 32000.410156f; + } else if (!strcmp(name, "s1111")) { + return 13.352669f; + } else if (!strcmp(name, "s112")) { + return 81335.929688f; + } else if (!strcmp(name, "s1112")) { + return 32009.560547f; + } else if (!strcmp(name, "s113")) { + return 32000.642578f; + } else if (!strcmp(name, "s1113")) { + return 40010.613281f; + } else if (!strcmp(name, "s114")) { + return 919.856323f; + } else if (!strcmp(name, "s115")) { + return 31727.289062f; + } else if (!strcmp(name, "s1115")) { + return 25487.052734f; + } else if (!strcmp(name, "s116")) { + return 32000.f; + } else if (!strcmp(name, "s118")) { + return 32353.884766f; + } else if (!strcmp(name, "s119")) { + return 86338.984375f; + } else if (!strcmp(name, "s1119")) { + return 201466.421875f; + } else if (!strcmp(name, "s121")) { + return 32009.027344f; + } else if (!strcmp(name, "s122")) { + return 48446.664062f; + } else if (!strcmp(name, "s123")) { + return 32003.285156f; + } else if (!strcmp(name, "s124")) { + return 32001.642578f; + } else if (!strcmp(name, "s125")) { + return 131072.f; + } else if (!strcmp(name, "s126")) { + return 66955.132812f; + } else if (!strcmp(name, "s127")) { + return 32003.285156f; + } else if (!strcmp(name, "s128")) { + return 80000.f; + } else if (!strcmp(name, "s131")) { + return 32009.027344f; + } else if (!strcmp(name, "s132")) { + return 65538.5625f; + } else if (!strcmp(name, "s141")) { + return 3307351.5f; + } else if (!strcmp(name, "s151")) { + return 32009.027344f; + } else if (!strcmp(name, "s152")) { + return 44020.523438f; + } else if (!strcmp(name, "s161")) { + return 64002.054688f; + } else if (!strcmp(name, "s1161")) { + return 23.546331f; + } else if (!strcmp(name, "s162")) { + return 32009.023438f; + } else if (!strcmp(name, "s171")) { + return 48448.019531f; + } else if (!strcmp(name, "s172")) { + return 48448.019531f; + } else if (!strcmp(name, "s173")) { + return 32001.626953f; + } else if (!strcmp(name, "s174")) { + return 32001.626953f; + } else if (!strcmp(name, "s175")) { + return 32009.023438f; + } else if (!strcmp(name, "s176")) { + return 32000.f; + } else if (!strcmp(name, "s211")) { + return 63983.308594f; + } else if (!strcmp(name, "s212")) { + return 42008.136719f; + } else if (!strcmp(name, "s1213")) { + return 14.450508f; + } else if (!strcmp(name, "s221")) { + return 615418176.f; + } else if (!strcmp(name, "s1221")) { + return 79623.265625f; + } else if (!strcmp(name, "s222")) { + return 32000.f; + } else if (!strcmp(name, "s231")) { + return 119107.445312f; + } else if (!strcmp(name, "s232")) { + return 65536.f; + } else if (!strcmp(name, "s1232")) { + return 2885.801514f; + } else if (!strcmp(name, "s233")) { + return 504911.65625f; + } else if (!strcmp(name, "s2233")) { + return 337652.8125f; + } else if (!strcmp(name, "s235")) { + return 44810.886719f; + } else if (!strcmp(name, "s241")) { + return 64000.f; + } else if (!strcmp(name, "s242")) { + return 1535966208.f; + } else if (!strcmp(name, "s243")) { + return 138653.21875f; + } else if (!strcmp(name, "s244")) { + return 64623.015625f; + } else if (!strcmp(name, "s1244")) { + return 36.141911f; + } else if (!strcmp(name, "s2244")) { + return 32.852161f; + } else if (!strcmp(name, "s251")) { + return 32004.367188f; + } else if (!strcmp(name, "s1251")) { + return 39967.507812f; + } else if (!strcmp(name, "s2251")) { + return 2.635388f; + } else if (!strcmp(name, "s3251")) { + return 13.59558f; + } else if (!strcmp(name, "s252")) { + return 63999.f; + } else if (!strcmp(name, "s253")) { + return 320115936.f; + } else if (!strcmp(name, "s254")) { + return 32000.f; + } else if (!strcmp(name, "s255")) { + return 31953.501953f; + } else if (!strcmp(name, "s256")) { + return 66207.828125f; + } else if (!strcmp(name, "s257")) { + return 163072.f; + } else if (!strcmp(name, "s258")) { + return 14.65278f; + } else if (!strcmp(name, "s261")) { + return 54894.515625f; + } else if (!strcmp(name, "s271")) { + return 97793.570312f; + } else if (!strcmp(name, "s272")) { + return 64000.f; + } else if (!strcmp(name, "s273")) { + return 96311.546875f; + } else if (!strcmp(name, "s274")) { + return 320133920.f; + } else if (!strcmp(name, "s275")) { + return 65536.f; + } else if (!strcmp(name, "s2275")) { + return 1640158.5f; + } else if (!strcmp(name, "s276")) { + return 97793.570312f; + } else if (!strcmp(name, "s277")) { + return 32000.f; + } else if (!strcmp(name, "s278")) { + return 64012.589844f; + } else if (!strcmp(name, "s279")) { + return 64014.289062f; + } else if (!strcmp(name, "s1279")) { + return 32.852161f; + } else if (!strcmp(name, "s2710")) { + return 96003.28125f; + } else if (!strcmp(name, "s2711")) { + return 97793.570312f; + } else if (!strcmp(name, "s2712")) { + return 97793.570312f; + } else if (!strcmp(name, "s281")) { + return 32000.f; + } else if (!strcmp(name, "s1281")) { + return INFINITY; + } else if (!strcmp(name, "s291")) { + return 32000.f; + } else if (!strcmp(name, "s292")) { + return 31953.501953f; + } else if (!strcmp(name, "s293")) { + return 31999.998047f; + } else if (!strcmp(name, "s2101")) { + return 229657.921875f; + } else if (!strcmp(name, "s2102")) { + return 256.f; + } else if (!strcmp(name, "s2111")) { + return 34544940.f; + } else if (!strcmp(name, "s311")) { + return 10.950721f; + } else if (!strcmp(name, "s31111")) { + return 10.950721f; + } else if (!strcmp(name, "s312")) { + return 1.030869f; + } else if (!strcmp(name, "s313")) { + return 1.644824f; + } else if (!strcmp(name, "s314")) { + return 1.f; + } else if (!strcmp(name, "s315")) { + return 54857.f; + } else if (!strcmp(name, "s316")) { + return 0.000031f; + } else if (!strcmp(name, "s317")) { + return 0.f; + } else if (!strcmp(name, "s318")) { + return 32002.f; + } else if (!strcmp(name, "s319")) { + return 43.802898f; + } else if (!strcmp(name, "s3110")) { + return 514.f; + } else if (!strcmp(name, "s13110")) { + return 3.f; + } else if (!strcmp(name, "s3111")) { + return 10.950725f; + } else if (!strcmp(name, "s3112")) { + return 1.644725f; + } else if (!strcmp(name, "s3113")) { + return 2.f; + } else if (!strcmp(name, "s321")) { + return 32000.f; + } else if (!strcmp(name, "s322")) { + return 32000.f; + } else if (!strcmp(name, "s323")) { + return 146472.4375f; + } else if (!strcmp(name, "s331")) { + return 32000.f; + } else if (!strcmp(name, "s332")) { + return -1.f; + } else if (!strcmp(name, "s341")) { + return 10.950721f; + } else if (!strcmp(name, "s342")) { + return 10.950721f; + } else if (!strcmp(name, "s343")) { + return 1567.932129f; + } else if (!strcmp(name, "s351")) { + return 2560660224.f; + } else if (!strcmp(name, "s1351")) { + return 21.901442f; + } else if (!strcmp(name, "s352")) { + return 1.644808f; + } else if (!strcmp(name, "s353")) { + return 320084192.f; + } else if (!strcmp(name, "s421")) { + return 32009.023438f; + } else if (!strcmp(name, "s1421")) { + return 16000.f; + } else if (!strcmp(name, "s422")) { + return 3.737715f; + } else if (!strcmp(name, "s423")) { + return 64006.683594f; + } else if (!strcmp(name, "s424")) { + return 822.364014f; + } else if (!strcmp(name, "s431")) { + return 196500.265625f; + } else if (!strcmp(name, "s441")) { + return 48448.019531f; + } else if (!strcmp(name, "s442")) { + return 40224.117188f; + } else if (!strcmp(name, "s443")) { + return 64895.867188f; + } else if (!strcmp(name, "s451")) { + return 32007.898438f; + } else if (!strcmp(name, "s452")) { + return 32511.939453f; + } else if (!strcmp(name, "s453")) { + return 21.901442f; + } else if (!strcmp(name, "s471")) { + return 64004.925781f; + } else if (!strcmp(name, "s481")) { + return 48448.019531f; + } else if (!strcmp(name, "s482")) { + return 48448.019531f; + } else if (!strcmp(name, "s491")) { + return 32001.640625f; + } else if (!strcmp(name, "s4112")) { + return 141504.875f; + } else if (!strcmp(name, "s4113")) { + return 32001.640625f; + } else if (!strcmp(name, "s4114")) { + return 32000.f; + } else if (!strcmp(name, "s4115")) { + return 1.038636f; + } else if (!strcmp(name, "s4116")) { + return 0.753265f; + } else if (!strcmp(name, "s4117")) { + return 32002.205078f; + } else if (!strcmp(name, "s4121")) { + return 48448.019531f; + } else if (!strcmp(name, "va")) { + return 1.644725f; + } else if (!strcmp(name, "vag")) { + return 1.644725f; + } else if (!strcmp(name, "vas")) { + return 1.644725f; + } else if (!strcmp(name, "vif")) { + return 1.644725f; + } else if (!strcmp(name, "vpv")) { + return 164487.78125f; + } else if (!strcmp(name, "vtv")) { + return 32000.f; + } else if (!strcmp(name, "vpvtv")) { + return 97793.570312f; + } else if (!strcmp(name, "vpvts")) { + return 17522152701952.f; + } else if (!strcmp(name, "vpvpv")) { + return 1.644725f; + } else if (!strcmp(name, "vtvtv")) { + return 32000.f; + } else if (!strcmp(name, "vsumr")) { + return 10.950725f; + } else if (!strcmp(name, "vdotr")) { + return 1.644824f; + } else if (!strcmp(name, "vbor")) { + return 31924.046875f; + } else { + fprintf(stderr, "Unknown function name passed to expected_result: %s\n", name); + exit(1); + } +} + +typedef real_t(*test_function_t)(struct args_t *); + +static _Bool is_checksum_same(real_t expected, real_t value) +{ + if (expected == INFINITY) + return value == INFINITY; + else if(expected == 0.f) + return value <= 0.01f; + else { + real_t fraction = value / expected; + return 0.99f <= fraction && fraction <= 1.01f; + } +} + +void run(test_function_t vector_func, const char *fname, void * arg_info) +{ + struct args_t func_args = {.arg_info=arg_info}; + + double result = vector_func(&func_args); + double expected_result = get_expected_result(fname); + + if (!is_checksum_same(expected_result, result)) + { + fprintf (stderr, "value: %f, expected: %f\n", result, expected_result); + __builtin_abort(); + } +} + +int +__attribute__((noipa)) +dummy(float a[LEN_1D], float b[LEN_1D], float c[LEN_1D], float d[LEN_1D], float e[LEN_1D], float aa[LEN_2D][LEN_2D], float bb[LEN_2D][LEN_2D], float cc[LEN_2D][LEN_2D], float s){ + // -- called in each loop to make all computations appear required + return 0; +} + +#pragma GCC pop_options diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s000.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s000.c new file mode 100644 index 00000000000..b5d5faab52f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s000.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s000(struct args_t * func_args) +{ +// linear dependence testing +// no dependence - vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s000, "s000", NULL); + + return 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/tsvc/vect-tsvc-s111.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s111.c new file mode 100644 index 00000000000..37e4684e1e5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s111.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s111(struct args_t * func_args) +{ +// linear dependence testing +// no dependence - vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s111, "s111", NULL); + + return 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/tsvc/vect-tsvc-s1111.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1111.c new file mode 100644 index 00000000000..cd7e84ebfe3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1111.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1111(struct args_t * func_args) +{ +// no dependence - vectorizable +// jump in data access + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1111, "s1111", NULL); + + return 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/tsvc/vect-tsvc-s1112.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1112.c new file mode 100644 index 00000000000..20cb3468101 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1112.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1112(struct args_t * func_args) +{ +// linear dependence testing +// loop reversal + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1112, "s1112", NULL); + + return 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/tsvc/vect-tsvc-s1113.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1113.c new file mode 100644 index 00000000000..d48362cb413 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1113.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1113(struct args_t * func_args) +{ +// linear dependence testing +// one iteration dependency on a(LEN_1D/2) but still vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1113, "s1113", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1115.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1115.c new file mode 100644 index 00000000000..f5bf8629d85 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1115.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1115(struct args_t * func_args) +{ +// linear dependence testing +// triangular saxpy loop + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1115, "s1115", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1119.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1119.c new file mode 100644 index 00000000000..16610fadd63 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1119.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1119(struct args_t * func_args) +{ +// linear dependence testing +// no dependence - vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1119, "s1119", NULL); + + return 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/tsvc/vect-tsvc-s112.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s112.c new file mode 100644 index 00000000000..3c6ae49f212 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s112.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s112(struct args_t * func_args) +{ +// linear dependence testing +// loop reversal + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s112, "s112", NULL); + + return 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/tsvc/vect-tsvc-s113.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s113.c new file mode 100644 index 00000000000..f22ab4c03b3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s113.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s113(struct args_t * func_args) +{ +// linear dependence testing +// a(i)=a(1) but no actual dependence cycle + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s113, "s113", NULL); + + return 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/tsvc/vect-tsvc-s114.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s114.c new file mode 100644 index 00000000000..dfc8180113e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s114.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s114(struct args_t * func_args) +{ +// linear dependence testing +// transpose vectorization +// Jump in data access - not vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s114, "s114", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s115.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s115.c new file mode 100644 index 00000000000..153cbf8aaca --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s115.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s115(struct args_t * func_args) +{ +// linear dependence testing +// triangular saxpy loop + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s115, "s115", NULL); + + return 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/tsvc/vect-tsvc-s116.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s116.c new file mode 100644 index 00000000000..c92be619bfb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s116.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s116(struct args_t * func_args) +{ +// linear dependence testing + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s116, "s116", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1161.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1161.c new file mode 100644 index 00000000000..c29e8043061 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1161.c @@ -0,0 +1,48 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1161(struct args_t * func_args) +{ +// control flow +// tests for recognition of loop independent dependences +// between statements in mutually exclusive regions. + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1161, "s1161", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s118.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s118.c new file mode 100644 index 00000000000..d1ec33b60c4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s118.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s118(struct args_t * func_args) +{ +// linear dependence testing +// potential dot product recursion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s118, "s118", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s119.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s119.c new file mode 100644 index 00000000000..43391c5e447 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s119.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s119(struct args_t * func_args) +{ +// linear dependence testing +// no dependence - vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s119, "s119", NULL); + + return 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/tsvc/vect-tsvc-s121.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s121.c new file mode 100644 index 00000000000..98a67ace817 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s121.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s121(struct args_t * func_args) +{ +// induction variable recognition +// loop with possible ambiguity because of scalar store + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s121, "s121", NULL); + + return 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/tsvc/vect-tsvc-s1213.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1213.c new file mode 100644 index 00000000000..011d5e92129 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1213.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1213(struct args_t * func_args) +{ +// statement reordering +// dependency needing temporary + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1213, "s1213", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s122.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s122.c new file mode 100644 index 00000000000..74c16f60d78 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s122.c @@ -0,0 +1,48 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s122(struct args_t * func_args) +{ +// induction variable recognition +// variable lower and upper bound, and stride +// reverse data access and jump in data access + + struct{int a;int b;} * x = func_args->arg_info; + int n1 = x->a; + int n3 = x->b; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s122, "s122", &(struct{int a;int b;}){n1, n3}); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1221.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1221.c new file mode 100644 index 00000000000..4ecccfd731c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1221.c @@ -0,0 +1,38 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1221(struct args_t * func_args) +{ +// run-time symbolic resolution + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1221, "s1221", NULL); + + return 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/tsvc/vect-tsvc-s123.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s123.c new file mode 100644 index 00000000000..7912f73ba41 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s123.c @@ -0,0 +1,47 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s123(struct args_t * func_args) +{ +// induction variable recognition +// induction variable under an if +// not vectorizable, the condition cannot be speculated + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s123, "s123", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1232.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1232.c new file mode 100644 index 00000000000..5eddc40be3c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1232.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1232(struct args_t * func_args) +{ +// loop interchange +// interchanging of triangular loops + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1232, "s1232", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s124.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s124.c new file mode 100644 index 00000000000..36292bedf09 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s124.c @@ -0,0 +1,47 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s124(struct args_t * func_args) +{ +// induction variable recognition +// induction variable under both sides of if (same value) + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s124, "s124", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1244.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1244.c new file mode 100644 index 00000000000..c847632abe8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1244.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1244(struct args_t * func_args) +{ +// node splitting +// cycle with ture and anti dependency + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1244, "s1244", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s125.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s125.c new file mode 100644 index 00000000000..679074300ba --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s125.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s125(struct args_t * func_args) +{ +// induction variable recognition +// induction variable in two loops; collapsing possible + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s125, "s125", NULL); + + return 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/tsvc/vect-tsvc-s1251.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1251.c new file mode 100644 index 00000000000..b2e099ccfe0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1251.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1251(struct args_t * func_args) +{ +// scalar and array expansion +// scalar expansion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1251, "s1251", NULL); + + return 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/tsvc/vect-tsvc-s126.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s126.c new file mode 100644 index 00000000000..476daa6315c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s126.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s126(struct args_t * func_args) +{ +// induction variable recognition +// induction variable in two loops; recurrence in inner loop + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s126, "s126", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s127.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s127.c new file mode 100644 index 00000000000..6f9a8216649 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s127.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s127(struct args_t * func_args) +{ +// induction variable recognition +// induction variable with multiple increments + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s127, "s127", NULL); + + return 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/tsvc/vect-tsvc-s1279.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1279.c new file mode 100644 index 00000000000..e204f387d71 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1279.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1279(struct args_t * func_args) +{ +// control flow +// vector if/gotos + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1279, "s1279", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s128.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s128.c new file mode 100644 index 00000000000..7b8874acec3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s128.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s128(struct args_t * func_args) +{ +// induction variables +// coupled induction variables +// jump in data access + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s128, "s128", NULL); + + return 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/tsvc/vect-tsvc-s1281.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1281.c new file mode 100644 index 00000000000..dba95a81973 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1281.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1281(struct args_t * func_args) +{ +// crossing thresholds +// index set splitting +// reverse data access + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1281, "s1281", NULL); + + return 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/tsvc/vect-tsvc-s131.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s131.c new file mode 100644 index 00000000000..73f58a7ff4c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s131.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s131(struct args_t * func_args) +{ +// global data flow analysis +// forward substitution + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s131, "s131", NULL); + + return 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/tsvc/vect-tsvc-s13110.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s13110.c new file mode 100644 index 00000000000..189d11a5a73 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s13110.c @@ -0,0 +1,51 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s13110(struct args_t * func_args) +{ +// reductions +// if to max with index reductio 2 dimensions + + initialise_arrays(__func__); + + 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); + } + + return max + xindex+1 + yindex+1; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s13110, "s13110", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s132.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s132.c new file mode 100644 index 00000000000..c2f5c2f2752 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s132.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s132(struct args_t * func_args) +{ +// global data flow analysis +// loop with multiple dimension ambiguous subscripts + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s132, "s132", NULL); + + return 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/tsvc/vect-tsvc-s1351.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1351.c new file mode 100644 index 00000000000..d020f909c0a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1351.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1351(struct args_t * func_args) +{ +// induction pointer recognition + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1351, "s1351", NULL); + + return 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/tsvc/vect-tsvc-s141.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s141.c new file mode 100644 index 00000000000..5e594bf5802 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s141.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s141(struct args_t * func_args) +{ +// 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 + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s141, "s141", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1421.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1421.c new file mode 100644 index 00000000000..043989fe4c4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s1421.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s1421(struct args_t * func_args) +{ +// storage classes and equivalencing +// equivalence- no overlap + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s1421, "s1421", NULL); + + return 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/tsvc/vect-tsvc-s151.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s151.c new file mode 100644 index 00000000000..46f71814ce8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s151.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { 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]; + } +} + +real_t s151(struct args_t * func_args) +{ +// interprocedural data flow analysis +// passing parameter information into a subroutine + + initialise_arrays(__func__); + + for (int nl = 0; nl < 5*iterations; nl++) { + s151s(a, b, 1); + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s151, "s151", NULL); + + return 0; +} + + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s152.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s152.c new file mode 100644 index 00000000000..d9c4186ba7a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s152.c @@ -0,0 +1,46 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { 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]; +} + +real_t s152(struct args_t * func_args) +{ +// interprocedural data flow analysis +// collecting information from a subroutine + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s152, "s152", NULL); + + return 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/tsvc/vect-tsvc-s161.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s161.c new file mode 100644 index 00000000000..875f82bff82 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s161.c @@ -0,0 +1,48 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s161(struct args_t * func_args) +{ +// control flow +// tests for recognition of loop independent dependences +// between statements in mutually exclusive regions. + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s161, "s161", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s162.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s162.c new file mode 100644 index 00000000000..521363d66fe --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s162.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s162(struct args_t * func_args) +{ +// control flow +// deriving assertions + + int k = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s162, "s162", &n1); + + return 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/tsvc/vect-tsvc-s171.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s171.c new file mode 100644 index 00000000000..291ec0ad353 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s171.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s171(struct args_t * func_args) +{ +// symbolics +// symbolic dependence tests + + int inc = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s171, "s171", &n1); + + return 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/tsvc/vect-tsvc-s172.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s172.c new file mode 100644 index 00000000000..33247c44880 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s172.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s172(struct args_t * func_args) +{ +// symbolics +// vectorizable if n3 .ne. 0 + + struct{int a;int b;} * x = func_args->arg_info; + int n1 = x->a; + int n3 = x->b; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s172, "s172", &(struct{int a;int b;}){n1, n3}); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s173.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s173.c new file mode 100644 index 00000000000..4bd166b9a0d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s173.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s173(struct args_t * func_args) +{ +// symbolics +// expression in loop bounds and subscripts + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s173, "s173", NULL); + + return 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/tsvc/vect-tsvc-s174.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s174.c new file mode 100644 index 00000000000..a4df4da265b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s174.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s174(struct args_t * func_args) +{ +// symbolics +// loop with subscript that may seem ambiguous + + int M = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s174, "s174", &(struct{int a;}){LEN_1D/2}); + + return 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/tsvc/vect-tsvc-s175.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s175.c new file mode 100644 index 00000000000..8888fb82143 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s175.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s175(struct args_t * func_args) +{ +// symbolics +// symbolic dependence tests + + int inc = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s175, "s175", &n1); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s176.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s176.c new file mode 100644 index 00000000000..708e5b45d78 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s176.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s176(struct args_t * func_args) +{ +// symbolics +// convolution + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s176, "s176", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2101.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2101.c new file mode 100644 index 00000000000..ad6e586a9e0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2101.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2101(struct args_t * func_args) +{ +// diagonals +// main diagonal calculation +// jump in data access + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2101, "s2101", NULL); + + return 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/tsvc/vect-tsvc-s2102.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2102.c new file mode 100644 index 00000000000..dd00eb83c32 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2102.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2102(struct args_t * func_args) +{ +// diagonals +// identity matrix, best results vectorize both inner and outer loops + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2102, "s2102", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s211.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s211.c new file mode 100644 index 00000000000..8881e80d810 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s211.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s211(struct args_t * func_args) +{ +// statement reordering +// statement reordering allows vectorization + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s211, "s211", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2111.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2111.c new file mode 100644 index 00000000000..8f01ca9f452 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2111.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2111(struct args_t * func_args) +{ +// wavefronts, it will make jump in data access + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2111, "s2111", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s212.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s212.c new file mode 100644 index 00000000000..c325526f4a3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s212.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s212(struct args_t * func_args) +{ +// statement reordering +// dependency needing temporary + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s212, "s212", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s221.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s221.c new file mode 100644 index 00000000000..0872180b36d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s221.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s221(struct args_t * func_args) +{ +// loop distribution +// loop that is partially recursive + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s221, "s221", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s222.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s222.c new file mode 100644 index 00000000000..51dc64ed11a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s222.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s222(struct args_t * func_args) +{ +// loop distribution +// partial loop vectorizatio recurrence in middle + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s222, "s222", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2233.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2233.c new file mode 100644 index 00000000000..c367c214ca7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2233.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2233(struct args_t * func_args) +{ +// loop interchange +// interchanging with one of two inner loops + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2233, "s2233", NULL); + + return 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/tsvc/vect-tsvc-s2244.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2244.c new file mode 100644 index 00000000000..9b0ca7447dd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2244.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2244(struct args_t * func_args) +{ +// node splitting +// cycle with ture and anti dependency + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2244, "s2244", NULL); + + return 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/tsvc/vect-tsvc-s2251.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2251.c new file mode 100644 index 00000000000..0ee266dbea9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2251.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2251(struct args_t * func_args) +{ +// scalar and array expansion +// scalar expansion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2251, "s2251", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2275.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2275.c new file mode 100644 index 00000000000..e182b83089e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2275.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2275(struct args_t * func_args) +{ +// loop distribution is needed to be able to interchange + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2275, "s2275", NULL); + + return 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/tsvc/vect-tsvc-s231.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s231.c new file mode 100644 index 00000000000..da523343e8f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s231.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s231(struct args_t * func_args) +{ +// loop interchange +// loop with data dependency + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s231, "s231", NULL); + + return 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/tsvc/vect-tsvc-s232.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s232.c new file mode 100644 index 00000000000..06b11c07c10 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s232.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s232(struct args_t * func_args) +{ +// loop interchange +// interchanging of triangular loops + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s232, "s232", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s233.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s233.c new file mode 100644 index 00000000000..177721810c4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s233.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s233(struct args_t * func_args) +{ +// loop interchange +// interchanging with one of two inner loops + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s233, "s233", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s235.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s235.c new file mode 100644 index 00000000000..1340b20cf83 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s235.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s235(struct args_t * func_args) +{ +// loop interchanging +// imperfectly nested loops + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s235, "s235", NULL); + + return 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/tsvc/vect-tsvc-s241.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s241.c new file mode 100644 index 00000000000..cbe741808e3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s241.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s241(struct args_t * func_args) +{ +// node splitting +// preloading necessary to allow vectorization + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s241, "s241", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s242.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s242.c new file mode 100644 index 00000000000..a07cb558465 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s242.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s242(struct args_t * func_args) +{ +// node splitting + + struct{real_t a;real_t b;} * x = func_args->arg_info; + real_t s1 = x->a; + real_t s2 = x->b; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s242, "s242", &(struct{real_t a;real_t b;}){s1, s2}); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s243.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s243.c new file mode 100644 index 00000000000..951aaeb0ac7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s243.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s243(struct args_t * func_args) +{ +// node splitting +// false dependence cycle breaking + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s243, "s243", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s244.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s244.c new file mode 100644 index 00000000000..eb4cfaad3b8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s244.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s244(struct args_t * func_args) +{ +// node splitting +// false dependence cycle breaking + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s244, "s244", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s251.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s251.c new file mode 100644 index 00000000000..a648f948347 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s251.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s251(struct args_t * func_args) +{ +// scalar and array expansion +// scalar expansion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s251, "s251", NULL); + + return 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/tsvc/vect-tsvc-s252.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s252.c new file mode 100644 index 00000000000..e2fa8427b37 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s252.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s252(struct args_t * func_args) +{ +// scalar and array expansion +// loop with ambiguous scalar temporary + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s252, "s252", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s253.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s253.c new file mode 100644 index 00000000000..6337ffca1cf --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s253.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s253(struct args_t * func_args) +{ +// scalar and array expansion +// scalar expansio assigned under if + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s253, "s253", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s254.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s254.c new file mode 100644 index 00000000000..647d0185e8e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s254.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s254(struct args_t * func_args) +{ +// scalar and array expansion +// carry around variable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s254, "s254", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s255.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s255.c new file mode 100644 index 00000000000..a8826ceec74 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s255.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s255(struct args_t * func_args) +{ +// scalar and array expansion +// carry around variables, 2 levels + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s255, "s255", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s256.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s256.c new file mode 100644 index 00000000000..65314ae17cd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s256.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s256(struct args_t * func_args) +{ +// scalar and array expansion +// array expansion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s256, "s256", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s257.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s257.c new file mode 100644 index 00000000000..2b8495702eb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s257.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s257(struct args_t * func_args) +{ +// scalar and array expansion +// array expansion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s257, "s257", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s258.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s258.c new file mode 100644 index 00000000000..e0f157a1656 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s258.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s258(struct args_t * func_args) +{ +// scalar and array expansion +// wrap-around scalar under an if + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s258, "s258", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s261.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s261.c new file mode 100644 index 00000000000..3e0633da94c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s261.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s261(struct args_t * func_args) +{ +// scalar and array expansion +// wrap-around scalar under an if + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s261, "s261", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s271.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s271.c new file mode 100644 index 00000000000..2c2f1229ddf --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s271.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s271(struct args_t * func_args) +{ +// control flow +// loop with singularity handling + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s271, "s271", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2710.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2710.c new file mode 100644 index 00000000000..ba869ef6b6d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2710.c @@ -0,0 +1,55 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2710(struct args_t * func_args) +{ +// control flow +// scalar and vector ifs + + int x = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2710, "s2710", &s1); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2711.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2711.c new file mode 100644 index 00000000000..41352dfd700 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2711.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2711(struct args_t * func_args) +{ +// control flow +// semantic if removal + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2711, "s2711", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2712.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2712.c new file mode 100644 index 00000000000..49f2e926ab4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s2712.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s2712(struct args_t * func_args) +{ +// control flow +// if to elemental min + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s2712, "s2712", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s272.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s272.c new file mode 100644 index 00000000000..f9313eaa897 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s272.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s272(struct args_t * func_args) +{ +// control flow +// loop with independent conditional + + int t = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s272, "s272", &s1); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s273.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s273.c new file mode 100644 index 00000000000..ff06d9fed6e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s273.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s273(struct args_t * func_args) +{ +// control flow +// simple loop with dependent conditional + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s273, "s273", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s274.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s274.c new file mode 100644 index 00000000000..0750040d713 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s274.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s274(struct args_t * func_args) +{ +// control flow +// complex loop with dependent conditional + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s274, "s274", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s275.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s275.c new file mode 100644 index 00000000000..f72d8a7bef7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s275.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s275(struct args_t * func_args) +{ +// control flow +// if around inner loop, interchanging needed + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s275, "s275", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s276.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s276.c new file mode 100644 index 00000000000..7342941138a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s276.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s276(struct args_t * func_args) +{ +// control flow +// if test using loop index + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s276, "s276", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s277.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s277.c new file mode 100644 index 00000000000..cf0132383c7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s277.c @@ -0,0 +1,49 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s277(struct args_t * func_args) +{ +// control flow +// test for dependences arising from guard variable computation. + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s277, "s277", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s278.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s278.c new file mode 100644 index 00000000000..12d8335582f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s278.c @@ -0,0 +1,47 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s278(struct args_t * func_args) +{ +// control flow +// if/goto to block if-then-else + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s278, "s278", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s279.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s279.c new file mode 100644 index 00000000000..bbdca953dd1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s279.c @@ -0,0 +1,51 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s279(struct args_t * func_args) +{ +// control flow +// vector if/gotos + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s279, "s279", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s281.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s281.c new file mode 100644 index 00000000000..ed2b4323ab8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s281.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s281(struct args_t * func_args) +{ +// crossing thresholds +// index set splitting +// reverse data access + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s281, "s281", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s291.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s291.c new file mode 100644 index 00000000000..ffa10ff8197 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s291.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s291(struct args_t * func_args) +{ +// loop peeling +// wrap around variable, 1 level + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s291, "s291", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s292.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s292.c new file mode 100644 index 00000000000..fe542620bc4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s292.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s292(struct args_t * func_args) +{ +// loop peeling +// wrap around variable, 2 levels +// similar to S291 + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s292, "s292", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s293.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s293.c new file mode 100644 index 00000000000..355b74bad3d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s293.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s293(struct args_t * func_args) +{ +// loop peeling +// a(i)=a(0) with actual dependence cycle, loop is vectorizable + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s293, "s293", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s311.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s311.c new file mode 100644 index 00000000000..11f5ee79fee --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s311.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s311(struct args_t * func_args) +{ +// reductions +// sum reduction + + initialise_arrays(__func__); + + 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); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s311, "s311", NULL); + + return 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/tsvc/vect-tsvc-s3110.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3110.c new file mode 100644 index 00000000000..eda64760100 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3110.c @@ -0,0 +1,52 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s3110(struct args_t * func_args) +{ +// reductions +// if to max with index reductio 2 dimensions +// similar to S315 + + initialise_arrays(__func__); + + 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); + } + + return max + xindex+1 + yindex+1; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s3110, "s3110", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3111.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3111.c new file mode 100644 index 00000000000..277e7b700b1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3111.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s3111(struct args_t * func_args) +{ +// reductions +// conditional sum reduction + + initialise_arrays(__func__); + + 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); + } + + return sum; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s3111, "s31111", NULL); + + return 0; +} + + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s31111.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s31111.c new file mode 100644 index 00000000000..ad2151357b7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s31111.c @@ -0,0 +1,54 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { 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; +} + +real_t s31111(struct args_t * func_args) +{ +// reductions +// sum reduction + + initialise_arrays(__func__); + + 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); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s31111, "s31111", NULL); + + return 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/tsvc/vect-tsvc-s3112.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3112.c new file mode 100644 index 00000000000..93ef9826ad7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3112.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s3112(struct args_t * func_args) +{ +// reductions +// sum reduction saving running sums + + initialise_arrays(__func__); + + 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); + } + + return sum; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s3112, "s3112", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3113.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3113.c new file mode 100644 index 00000000000..f7dede85ff9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3113.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s3113(struct args_t * func_args) +{ +// reductions +// maximum of absolute value + + initialise_arrays(__func__); + + 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); + } + + return max; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s3113, "s3113", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s312.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s312.c new file mode 100644 index 00000000000..43811973d1f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s312.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s312(struct args_t * func_args) +{ +// reductions +// product reduction + + initialise_arrays(__func__); + + 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); + } + + return prod; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s312, "s312", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s313.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s313.c new file mode 100644 index 00000000000..e58a5391f6f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s313.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s313(struct args_t * func_args) +{ +// reductions +// dot product + + initialise_arrays(__func__); + + 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); + } + + return dot; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s313, "s313", NULL); + + return 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/tsvc/vect-tsvc-s314.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s314.c new file mode 100644 index 00000000000..4d92ec181a0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s314.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s314(struct args_t * func_args) +{ +// reductions +// if to max reduction + + initialise_arrays(__func__); + + 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); + } + + return x; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s314, "s314", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s315.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s315.c new file mode 100644 index 00000000000..8d734a0f7b6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s315.c @@ -0,0 +1,50 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s315(struct args_t * func_args) +{ +// reductions +// if to max with index reductio 1 dimension + + initialise_arrays(__func__); + + 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); + } + + return index + x + 1; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s315, "s315", NULL); + + return 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/tsvc/vect-tsvc-s316.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s316.c new file mode 100644 index 00000000000..7d102018da8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s316.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s316(struct args_t * func_args) +{ +// reductions +// if to min reduction + + initialise_arrays(__func__); + + 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); + } + + return x; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s316, "s316", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s317.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s317.c new file mode 100644 index 00000000000..86a608b3fcc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s317.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s317(struct args_t * func_args) +{ +// reductions +// product reductio vectorize with +// 1. scalar expansion of factor, and product reduction +// 2. closed form solution: q = factor**n + + initialise_arrays(__func__); + + 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); + } + + return q; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s317, "s317", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s318.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s318.c new file mode 100644 index 00000000000..cc67bfaa2f7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s318.c @@ -0,0 +1,54 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s318(struct args_t * func_args) +{ +// reductions +// isamax, max absolute value, increments not equal to 1 + + int inc = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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); + } + + return max + index + 1; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s318, "s318", &n1); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s319.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s319.c new file mode 100644 index 00000000000..6eb71187ef6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s319.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s319(struct args_t * func_args) +{ +// reductions +// coupled reductions + + initialise_arrays(__func__); + + 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); + } + + return sum; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s319, "s319", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s321.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s321.c new file mode 100644 index 00000000000..90ac13ea3a4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s321.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s321(struct args_t * func_args) +{ +// recurrences +// first order linear recurrence + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s321, "s321", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s322.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s322.c new file mode 100644 index 00000000000..0655d395e6c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s322.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s322(struct args_t * func_args) +{ +// recurrences +// second order linear recurrence + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s322, "s322", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s323.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s323.c new file mode 100644 index 00000000000..2d49fb6d527 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s323.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s323(struct args_t * func_args) +{ +// recurrences +// coupled recurrence + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s323, "s323", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3251.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3251.c new file mode 100644 index 00000000000..51ca17396be --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s3251.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s3251(struct args_t * func_args) +{ +// scalar and array expansion +// scalar expansion + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s3251, "s3251", NULL); + + return 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/tsvc/vect-tsvc-s331.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s331.c new file mode 100644 index 00000000000..e580df75b21 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s331.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s331(struct args_t * func_args) +{ +// search loops +// if to last-1 + + initialise_arrays(__func__); + + 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); + } + + return j+1; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s331, "s331", NULL); + + return 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/tsvc/vect-tsvc-s332.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s332.c new file mode 100644 index 00000000000..6d4cc3e3d32 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s332.c @@ -0,0 +1,52 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s332(struct args_t * func_args) +{ +// search loops +// first value greater than threshold + + int t = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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); + } + + return value; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s332, "s332", &s1); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s341.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s341.c new file mode 100644 index 00000000000..2aff646eaa7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s341.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s341(struct args_t * func_args) +{ +// packing +// pack positive values +// not vectorizable, value of j in unknown at each iteration + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s341, "s341", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s342.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s342.c new file mode 100644 index 00000000000..bcdc74f57b2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s342.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s342(struct args_t * func_args) +{ +// packing +// unpacking +// not vectorizable, value of j in unknown at each iteration + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s342, "s342", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s343.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s343.c new file mode 100644 index 00000000000..768c06e3223 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s343.c @@ -0,0 +1,47 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s343(struct args_t * func_args) +{ +// packing +// pack 2-d array into one dimension +// not vectorizable, value of k in unknown at each iteration + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s343, "s343", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s351.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s351.c new file mode 100644 index 00000000000..b5875d18036 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s351.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s351(struct args_t * func_args) +{ +// loop rerolling +// unrolled saxpy + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s351, "s351", NULL); + + return 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/tsvc/vect-tsvc-s352.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s352.c new file mode 100644 index 00000000000..11d2412a05c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s352.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s352(struct args_t * func_args) +{ +// loop rerolling +// unrolled dot product + + initialise_arrays(__func__); + + 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); + } + + return dot; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s352, "s352", NULL); + + return 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/tsvc/vect-tsvc-s353.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s353.c new file mode 100644 index 00000000000..0250d681be6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s353.c @@ -0,0 +1,47 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s353(struct args_t * func_args) +{ +// loop rerolling +// unrolled sparse saxpy +// gather is required + + int * __restrict__ ip = func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s353, "s353", ip); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4112.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4112.c new file mode 100644 index 00000000000..bca9a1b10c1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4112.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s4112(struct args_t * func_args) +{ +// indirect addressing +// sparse saxpy +// gather is required + + struct{int * __restrict__ a;real_t b;} * x = func_args->arg_info; + int * __restrict__ ip = x->a; + real_t s = x->b; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4112, "s4112", &(struct{int*a;real_t b;}){ip, s1}); + + return 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/tsvc/vect-tsvc-s4113.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4113.c new file mode 100644 index 00000000000..3c616112634 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4113.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s4113(struct args_t * func_args) +{ +// indirect addressing +// indirect addressing on rhs and lhs +// gather and scatter is required + + int * __restrict__ ip = func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4113, "s4113", ip); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4114.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4114.c new file mode 100644 index 00000000000..b305900e444 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4114.c @@ -0,0 +1,47 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s4114(struct args_t * func_args) +{ +// indirect addressing +// mix indirect addressing with variable lower and upper bounds +// gather is required + + struct{int * __restrict__ a;int b;} * x = func_args->arg_info; + int * __restrict__ ip = x->a; + int n1 = x->b; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4114, "s4114", &(struct{int*a;int b;}){ip, n1}); + + return 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/tsvc/vect-tsvc-s4115.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4115.c new file mode 100644 index 00000000000..f85e75e4710 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4115.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s4115(struct args_t * func_args) +{ +// indirect addressing +// sparse dot product +// gather is required + + int * __restrict__ ip = func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return sum; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4115, "s4115", ip); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4116.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4116.c new file mode 100644 index 00000000000..95a771ec0d1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4116.c @@ -0,0 +1,49 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s4116(struct args_t * func_args) +{ +// indirect addressing +// more complicated sparse sdot +// gather is required + + struct{int * __restrict__ a;int b;int c;} * x = func_args->arg_info; + int * __restrict__ ip = x->a; + int j = x->b; + int inc = x->c; + + initialise_arrays(__func__); + + 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.); + } + + return sum; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4116, "s4116", &(struct{int * a; int b; int c;}){ip, LEN_2D/2, n1}); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4117.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4117.c new file mode 100644 index 00000000000..a1d757b7d09 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4117.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s4117(struct args_t * func_args) +{ +// indirect addressing +// seq function + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4117, "s4117", NULL); + + return 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/tsvc/vect-tsvc-s4121.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4121.c new file mode 100644 index 00000000000..54aa9d07c4a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s4121.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { 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; +} + +real_t s4121(struct args_t * func_args) +{ +// statement functions +// elementwise multiplication + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s4121, "s4121", NULL); + + return 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/tsvc/vect-tsvc-s421.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s421.c new file mode 100644 index 00000000000..e6c00c5bded --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s421.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s421(struct args_t * func_args) +{ +// storage classes and equivalencing +// equivalence- no overlap + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s421, "s421", NULL); + + return 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/tsvc/vect-tsvc-s422.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s422.c new file mode 100644 index 00000000000..4d491da5309 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s422.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s422(struct args_t * func_args) +{ +// storage classes and equivalencing +// common and equivalence statement +// anti-dependence, threshold of 4 + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s422, "s422", NULL); + + return 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/tsvc/vect-tsvc-s423.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s423.c new file mode 100644 index 00000000000..7605f0575c5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s423.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s423(struct args_t * func_args) +{ +// storage classes and equivalencing +// common and equivalenced variables - with anti-dependence + + // do this again here + int vl = 64; + xx = flat_2d_array + vl; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s423, "s423", NULL); + + return 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/tsvc/vect-tsvc-s424.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s424.c new file mode 100644 index 00000000000..211f2d4ab05 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s424.c @@ -0,0 +1,44 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s424(struct args_t * func_args) +{ +// 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; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s424, "s424", NULL); + + return 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/tsvc/vect-tsvc-s431.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s431.c new file mode 100644 index 00000000000..f2b03588db1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s431.c @@ -0,0 +1,43 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s431(struct args_t * func_args) +{ +// parameters +// parameter statement + + int k1=1; + int k2=2; + int k=2*k1-k2; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s431, "s431", NULL); + + return 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/tsvc/vect-tsvc-s441.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s441.c new file mode 100644 index 00000000000..485cbe8852d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s441.c @@ -0,0 +1,45 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s441(struct args_t * func_args) +{ +// non-logical if's +// arithmetic if + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s441, "s441", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s442.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s442.c new file mode 100644 index 00000000000..a24c562e5e3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s442.c @@ -0,0 +1,57 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s442(struct args_t * func_args) +{ +// non-logical if's +// computed goto + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s442, "s442", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s443.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s443.c new file mode 100644 index 00000000000..58c0cf277a1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s443.c @@ -0,0 +1,50 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s443(struct args_t * func_args) +{ +// non-logical if's +// arithmetic if + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s443, "s443", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s451.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s451.c new file mode 100644 index 00000000000..3e0b2e12b46 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s451.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s451(struct args_t * func_args) +{ +// intrinsic functions +// intrinsics + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s451, "s451", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s452.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s452.c new file mode 100644 index 00000000000..fe97c4d40f5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s452.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s452(struct args_t * func_args) +{ +// intrinsic functions +// seq function + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s452, "s452", NULL); + + return 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/tsvc/vect-tsvc-s453.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s453.c new file mode 100644 index 00000000000..25710641f1a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s453.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s453(struct args_t * func_args) +{ +// induction varibale recognition + + real_t s; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s453, "s453", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s471.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s471.c new file mode 100644 index 00000000000..b842ddaeedc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s471.c @@ -0,0 +1,49 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { 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; +} + +real_t s471(struct args_t * func_args){ + +// call statements + + int m = LEN_1D; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s471, "s471", NULL); + + return 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/tsvc/vect-tsvc-s481.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s481.c new file mode 100644 index 00000000000..4387ea77949 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s481.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s481(struct args_t * func_args) +{ +// non-local goto's +// stop statement + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s481, "s481", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s482.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s482.c new file mode 100644 index 00000000000..cb9434e1473 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s482.c @@ -0,0 +1,40 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s482(struct args_t * func_args) +{ +// non-local goto's +// other loop exit with code before exit + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s482, "s482", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s491.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s491.c new file mode 100644 index 00000000000..baf78ac28c2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-s491.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t s491(struct args_t * func_args) +{ +// vector semantics +// indirect addressing on lhs, store in sequence +// scatter is required + + int * __restrict__ ip = func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&s491, "s491", ip); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-va.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-va.c new file mode 100644 index 00000000000..441b5bda219 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-va.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t va(struct args_t * func_args) +{ +// control loops +// vector assignment + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&va, "va", NULL); + + return 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/tsvc/vect-tsvc-vag.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vag.c new file mode 100644 index 00000000000..9213b2787b2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vag.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vag(struct args_t * func_args) +{ +// control loops +// vector assignment, gather +// gather is required + + int * __restrict__ ip = func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vag, "vag", ip); + + return 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/tsvc/vect-tsvc-vas.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vas.c new file mode 100644 index 00000000000..2b2ba0bc785 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vas.c @@ -0,0 +1,42 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vas(struct args_t * func_args) +{ +// control loops +// vector assignment, scatter +// scatter is required + + int * __restrict__ ip = func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vas, "vas", ip); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vbor.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vbor.c new file mode 100644 index 00000000000..801410db295 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vbor.c @@ -0,0 +1,54 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vbor(struct args_t * func_args) +{ +// control loops +// basic operations rates, isolate arithmetic from memory traffic +// all combinations of three, 59 flops for 6 loads and 1 store. + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vbor, "vbor", NULL); + + return 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/tsvc/vect-tsvc-vdotr.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vdotr.c new file mode 100644 index 00000000000..80ed9f81e50 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vdotr.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vdotr(struct args_t * func_args) +{ +// control loops +// vector dot product reduction + + initialise_arrays(__func__); + + 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); + } + + return dot; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vdotr, "vdotr", NULL); + + return 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/tsvc/vect-tsvc-vif.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vif.c new file mode 100644 index 00000000000..6d06f23b257 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vif.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vif(struct args_t * func_args) +{ +// control loops +// vector if + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vif, "vif", NULL); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpv.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpv.c new file mode 100644 index 00000000000..232904f887f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpv.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vpv(struct args_t * func_args) +{ +// control loops +// vector plus vector + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vpv, "vpv", NULL); + + return 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/tsvc/vect-tsvc-vpvpv.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvpv.c new file mode 100644 index 00000000000..b4d085016f2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvpv.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vpvpv(struct args_t * func_args) +{ +// control loops +// vector plus vector plus vector + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vpvpv, "vpvpv", NULL); + + return 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/tsvc/vect-tsvc-vpvts.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvts.c new file mode 100644 index 00000000000..f193afa5728 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvts.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vpvts(struct args_t * func_args) +{ +// control loops +// vector plus vector times scalar + + real_t s = *(int*)func_args->arg_info; + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vpvts, "vpvts", &s1); + + return 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/tsvc/vect-tsvc-vpvtv.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvtv.c new file mode 100644 index 00000000000..b726b27e5e3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vpvtv.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vpvtv(struct args_t * func_args) +{ +// control loops +// vector plus vector times vector + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vpvtv, "vpvtv", NULL); + + return 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/tsvc/vect-tsvc-vsumr.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vsumr.c new file mode 100644 index 00000000000..0847eaed1e7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vsumr.c @@ -0,0 +1,41 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vsumr(struct args_t * func_args) +{ +// control loops +// vector sum reduction + + initialise_arrays(__func__); + + 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); + } + + return sum; +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vsumr, "vsumr", NULL); + + return 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/tsvc/vect-tsvc-vtv.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vtv.c new file mode 100644 index 00000000000..d3457d483dc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vtv.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vtv(struct args_t * func_args) +{ +// control loops +// vector times vector + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vtv, "vtv", NULL); + + return 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/tsvc/vect-tsvc-vtvtv.c b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vtvtv.c new file mode 100644 index 00000000000..32148ec4c47 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc/vect-tsvc-vtvtv.c @@ -0,0 +1,39 @@ +/* This file is distributed under the University of Illinois Open Source + License. See license.txt for details. */ + +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t vtvtv(struct args_t * func_args) +{ +// control loops +// vector times vector times vector + + initialise_arrays(__func__); + + 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.); + } + + return calc_checksum(__func__); +} + +int main (int argc, char **argv) +{ + int n1 = 1; + int n3 = 1; + int* ip; + real_t s1,s2; + init(&ip, &s1, &s2); + + run(&vtvtv, "vtvtv", NULL); + + return 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.exp b/gcc/testsuite/gcc.dg/vect/vect.exp index dca9a4db6f6..7e333983f0d 100644 --- a/gcc/testsuite/gcc.dg/vect/vect.exp +++ b/gcc/testsuite/gcc.dg/vect/vect.exp @@ -94,6 +94,9 @@ foreach flags $VECT_ADDITIONAL_FLAGS { et-dg-runtest dg-runtest [lsort \ [glob -nocomplain $srcdir/$subdir/vect-*.\[cS\]]] \ $flags $DEFAULT_VECTCFLAGS + et-dg-runtest dg-runtest [lsort \ + [glob -nocomplain $srcdir/$subdir/tsvc/*.\[cS\]]] \ + $flags $DEFAULT_VECTCFLAGS et-dg-runtest dg-runtest [lsort \ [glob -nocomplain $srcdir/$subdir/slp-*.\[cS\]]] \ $flags $DEFAULT_VECTCFLAGS