From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1851) id 659E83857C71; Fri, 15 Oct 2021 16:32:39 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 659E83857C71 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)] Add TSVC tests. X-Act-Checkin: gcc X-Git-Author: Martin Liska X-Git-Refname: refs/users/marxin/heads/TSVC X-Git-Oldrev: 4764049dd620affcd3e2658dc7f03a6616370a29 X-Git-Newrev: b5c327388d6572ed99858d2d48be28db86b4230f Message-Id: <20211015163239.659E83857C71@sourceware.org> Date: Fri, 15 Oct 2021 16:32:39 +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: Fri, 15 Oct 2021 16:32:39 -0000 https://gcc.gnu.org/g:b5c327388d6572ed99858d2d48be28db86b4230f commit b5c327388d6572ed99858d2d48be28db86b4230f Author: Martin Liska Date: Fri Oct 15 18:31:48 2021 +0200 Add TSVC tests. Diff: --- gcc/testsuite/gcc.dg/vect/tsvc.h | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c | 28 +++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c | 29 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c | 27 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c | 27 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c | 26 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c | 31 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c | 26 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c | 27 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c | 28 +++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c | 18 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c | 32 ++++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c | 29 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c | 27 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c | 31 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c | 32 ++++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c | 35 ++++++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c | 31 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c | 31 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c | 26 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c | 29 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c | 27 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c | 27 ++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c | 30 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c | 30 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c | 23 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c | 25 +++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c | 37 ++++++++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c | 30 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c | 30 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c | 19 ++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c | 35 ++++++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c | 21 ++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c | 22 +++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c | 20 +++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c | 20 +++++++++++++++ 152 files changed, 3533 insertions(+) diff --git a/gcc/testsuite/gcc.dg/vect/tsvc.h b/gcc/testsuite/gcc.dg/vect/tsvc.h new file mode 100644 index 00000000000..cfc00cba0c5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/tsvc.h @@ -0,0 +1,25 @@ +#define iterations 100000 +#define LEN_1D 32000 +#define LEN_2D 256 +#define ARRAY_ALIGNMENT 64 + +#include +#include + +typedef float real_t; +#define ABS fabsf + +int dummy(real_t[LEN_1D], real_t[LEN_1D], real_t[LEN_1D], real_t[LEN_1D], + real_t[LEN_1D], real_t[LEN_2D][LEN_2D], real_t[LEN_2D][LEN_2D], + real_t[LEN_2D][LEN_2D], real_t); + +extern __attribute__((aligned(ARRAY_ALIGNMENT))) +real_t flat_2d_array[LEN_2D * LEN_2D]; +extern __attribute__((aligned(ARRAY_ALIGNMENT))) real_t x[LEN_1D]; +extern __attribute__((aligned(ARRAY_ALIGNMENT))) real_t a[LEN_1D], b[LEN_1D], + c[LEN_1D], d[LEN_1D], e[LEN_1D], aa[LEN_2D][LEN_2D], bb[LEN_2D][LEN_2D], + cc[LEN_2D][LEN_2D], tt[LEN_2D][LEN_2D]; +extern __attribute__((aligned(ARRAY_ALIGNMENT))) int indx[LEN_1D]; + +extern real_t* __restrict__ xx; +extern real_t* yy; diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c new file mode 100644 index 00000000000..70d420d7955 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s000 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i] + 1; + } + dummy((real_t*)a, (real_t*)b, (real_t*)c, (real_t*)d, (real_t*)e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c new file mode 100644 index 00000000000..44cd202c8a0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s111 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 1; i < LEN_1D; i += 2) { + a[i] = a[i - 1] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c new file mode 100644 index 00000000000..b9545c883e8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1111 (void) +{ +// no dependence - vectorizable +// jump in data access + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D/2; i++) { + a[2*i] = c[i] * b[i] + d[i] * b[i] + c[i] * c[i] + d[i] * b[i] + d[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c new file mode 100644 index 00000000000..a270d82ed82 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1112 (void) +{ +// linear dependence testing +// loop reversal + + + for (int nl = 0; nl < iterations*3; nl++) { + for (int i = LEN_1D - 1; i >= 0; i--) { + a[i] = b[i] + (real_t) 1.; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c new file mode 100644 index 00000000000..f451f387d84 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1113 (void) +{ +// linear dependence testing +// one iteration dependency on a(LEN_1D/2) but still vectorizable + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[LEN_1D/2] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c new file mode 100644 index 00000000000..30f2a1358b1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1115 (void) +{ +// linear dependence testing +// triangular saxpy loop + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[i][j] = aa[i][j]*cc[j][i] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c new file mode 100644 index 00000000000..f628c6d2a7a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1119 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[i][j] = aa[i-1][j] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c new file mode 100644 index 00000000000..c71a2ef7086 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s112 (void) +{ +// linear dependence testing +// loop reversal + + + for (int nl = 0; nl < 3*iterations; nl++) { + for (int i = LEN_1D - 2; i >= 0; i--) { + a[i+1] = a[i] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c new file mode 100644 index 00000000000..aa32e546427 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s113 (void) +{ +// linear dependence testing +// a(i)=a(1) but no actual dependence cycle + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] = a[0] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c new file mode 100644 index 00000000000..538931c2c80 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s114 (void) +{ +// linear dependence testing +// transpose vectorization +// Jump in data access - not vectorizable + + + for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < i; j++) { + aa[i][j] = aa[j][i] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c new file mode 100644 index 00000000000..f9bc87a6353 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s115 (void) +{ +// linear dependence testing +// triangular saxpy loop + + + for (int nl = 0; nl < 1000*(iterations/LEN_2D); nl++) { + for (int j = 0; j < LEN_2D; j++) { + for (int i = j+1; i < LEN_2D; i++) { + a[i] -= aa[j][i] * a[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c new file mode 100644 index 00000000000..b0a34234ff6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s116 (void) +{ +// linear dependence testing + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D - 5; i += 5) { + a[i] = a[i + 1] * a[i]; + a[i + 1] = a[i + 2] * a[i + 1]; + a[i + 2] = a[i + 3] * a[i + 2]; + a[i + 3] = a[i + 4] * a[i + 3]; + a[i + 4] = a[i + 5] * a[i + 4]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c new file mode 100644 index 00000000000..c00dffd6334 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c @@ -0,0 +1,28 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1161 (void) +{ +// control flow +// tests for recognition of loop independent dependences +// between statements in mutually exclusive regions. + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; ++i) { + if (c[i] < (real_t)0.) { + goto L20; + } + a[i] = c[i] + d[i] * e[i]; + goto L10; +L20: + b[i] = a[i] + d[i] * d[i]; +L10: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c new file mode 100644 index 00000000000..cb87d2a9169 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s118 (void) +{ +// linear dependence testing +// potential dot product recursion + + + for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 0; j <= i - 1; j++) { + a[i] += bb[j][i] * a[i-j-1]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c new file mode 100644 index 00000000000..cca70e94256 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s119 (void) +{ +// linear dependence testing +// no dependence - vectorizable + + + for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + aa[i][j] = aa[i-1][j-1] + bb[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c new file mode 100644 index 00000000000..10a0af5d2bb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s121 (void) +{ +// induction variable recognition +// loop with possible ambiguity because of scalar store + + + int j; + for (int nl = 0; nl < 3*iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + j = i + 1; + a[i] = a[j] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c new file mode 100644 index 00000000000..12252a72883 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1213 (void) +{ +// statement reordering +// dependency needing temporary + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D-1; i++) { + a[i] = b[i-1]+c[i]; + b[i] = a[i+1]*d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c new file mode 100644 index 00000000000..494e5b909bb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int a;int b;}; + +void s122 (struct arg *x) +{ +// induction variable recognition +// variable lower and upper bound, and stride +// reverse data access and jump in data access + + int n1 = x->a; + int n3 = x->b; + + + int j, k; + for (int nl = 0; nl < iterations; nl++) { + j = 1; + k = 0; + for (int i = n1-1; i < LEN_1D; i += n3) { + k += j; + a[i] += b[LEN_1D - k]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c new file mode 100644 index 00000000000..6ebac685d90 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1221 (void) +{ +// run-time symbolic resolution + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 4; i < LEN_1D; i++) { + b[i] = b[i - 4] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c new file mode 100644 index 00000000000..ec2ab0902e5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s123 (void) +{ +// induction variable recognition +// induction variable under an if +// not vectorizable, the condition cannot be speculated + + + int j; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < (LEN_1D/2); i++) { + j++; + a[j] = b[i] + d[i] * e[i]; + if (c[i] > (real_t)0.) { + j++; + a[j] = c[i] + d[i] * e[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c new file mode 100644 index 00000000000..5f7e114adc7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1232 (void) +{ +// loop interchange +// interchanging of triangular loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int j = 0; j < LEN_2D; j++) { + for (int i = j; i < LEN_2D; i++) { + aa[i][j] = bb[i][j] + cc[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c new file mode 100644 index 00000000000..ee83271e8f6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s124 (void) +{ +// induction variable recognition +// induction variable under both sides of if (same value) + + + int j; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + j++; + a[j] = b[i] + d[i] * e[i]; + } else { + j++; + a[j] = c[i] + d[i] * e[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c new file mode 100644 index 00000000000..108d4db0af1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1244 (void) +{ +// node splitting +// cycle with ture and anti dependency + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = b[i] + c[i] * c[i] + b[i]*b[i] + c[i]; + d[i] = a[i] + a[i+1]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c new file mode 100644 index 00000000000..8cfc5470098 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s125 (void) +{ +// induction variable recognition +// induction variable in two loops; collapsing possible + + + int k; + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + k = -1; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + k++; + flat_2d_array[k] = aa[i][j] + bb[i][j] * cc[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c new file mode 100644 index 00000000000..efe1d3afac6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1251 (void) +{ +// scalar and array expansion +// scalar expansion + + + real_t s; + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + s = b[i]+c[i]; + b[i] = a[i]+d[i]; + a[i] = s*e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c new file mode 100644 index 00000000000..45c49f5ebf1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s126 (void) +{ +// induction variable recognition +// induction variable in two loops; recurrence in inner loop + + + int k; + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + k = 1; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + bb[j][i] = bb[j-1][i] + flat_2d_array[k-1] * cc[j][i]; + ++k; + } + ++k; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c new file mode 100644 index 00000000000..a54a462ed49 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s127 (void) +{ +// induction variable recognition +// induction variable with multiple increments + + + int j; + for (int nl = 0; nl < 2*iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D/2; i++) { + j++; + a[j] = b[i] + c[i] * d[i]; + j++; + a[j] = b[i] + d[i] * e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c new file mode 100644 index 00000000000..cae4cc6b97e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1279 (void) +{ +// control flow +// vector if/gotos + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] < (real_t)0.) { + if (b[i] > a[i]) { + c[i] += d[i] * e[i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c new file mode 100644 index 00000000000..6849009ebfa --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s128 (void) +{ +// induction variables +// coupled induction variables +// jump in data access + + + int j, k; + for (int nl = 0; nl < 2*iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D/2; i++) { + k = j + 1; + a[i] = b[k] - d[i]; + j = k + 1; + b[k] = a[i] + c[k]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c new file mode 100644 index 00000000000..4e98605d31c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1281 (void) +{ +// crossing thresholds +// index set splitting +// reverse data access + + + real_t x; + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + x = b[i]*c[i] + a[i]*d[i] + e[i]; + a[i] = x-(real_t)1.0; + b[i] = x; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c new file mode 100644 index 00000000000..04e04227399 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s131 (void) +{ +// global data flow analysis +// forward substitution + + + int m = 1; + for (int nl = 0; nl < 5*iterations; nl++) { + for (int i = 0; i < LEN_1D - 1; i++) { + a[i] = a[i + m] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c new file mode 100644 index 00000000000..b4523ea6a1b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s13110 (void) +{ +// reductions +// if to max with index reductio 2 dimensions + + + int xindex, yindex; + real_t max, chksum; + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + max = aa[(0)][0]; + xindex = 0; + yindex = 0; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + if (aa[i][j] > max) { + max = aa[i][j]; + xindex = i; + yindex = j; + } + } + } + chksum = max + (real_t) xindex + (real_t) yindex; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c new file mode 100644 index 00000000000..6ec23eae8a5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s132 (void) +{ +// global data flow analysis +// loop with multiple dimension ambiguous subscripts + + + int m = 0; + int j = m; + int k = m+1; + for (int nl = 0; nl < 400*iterations; nl++) { + for (int i= 1; i < LEN_2D; i++) { + aa[j][i] = aa[k][i-1] + b[i] * c[1]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c new file mode 100644 index 00000000000..6c35cbc0773 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1351 (void) +{ +// induction pointer recognition + + + for (int nl = 0; nl < 8*iterations; nl++) { + real_t* __restrict__ A = a; + real_t* __restrict__ B = b; + real_t* __restrict__ C = c; + for (int i = 0; i < LEN_1D; i++) { + *A = *B+*C; + A++; + B++; + C++; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c new file mode 100644 index 00000000000..d124b14a2d8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s141 (void) +{ +// nonlinear dependence testing +// walk a row in a symmetric packed array +// element a(i,j) for (int j>i) stored in location j*(j-1)/2+i + + + int k; + for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + k = (i+1) * ((i+1) - 1) / 2 + (i+1)-1; + for (int j = i; j < LEN_2D; j++) { + flat_2d_array[k] += bb[j][i]; + k += j+1; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c new file mode 100644 index 00000000000..578bdd33154 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s1421 (void) +{ +// storage classes and equivalencing +// equivalence- no overlap + + + xx = &b[LEN_1D/2]; + + for (int nl = 0; nl < 8*iterations; nl++) { + for (int i = 0; i < LEN_1D/2; i++) { + b[i] = xx[i] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c new file mode 100644 index 00000000000..229bcc9610d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s151s(real_t a[LEN_1D], real_t b[LEN_1D], int m) +{ + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = a[i + m] + b[i]; + } +} + +void s151 (void) +{ +// interprocedural data flow analysis +// passing parameter information into a subroutine + + + for (int nl = 0; nl < 5*iterations; nl++) { + s151s(a, b, 1); + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c new file mode 100644 index 00000000000..ca08dd2a62a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s152s(real_t a[LEN_1D], real_t b[LEN_1D], real_t c[LEN_1D], int i) +{ + a[i] += b[i] * c[i]; +} + +void s152 (void) +{ +// interprocedural data flow analysis +// collecting information from a subroutine + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + b[i] = d[i] * e[i]; + s152s(a, b, c, i); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c new file mode 100644 index 00000000000..5282a308eec --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c @@ -0,0 +1,28 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s161 (void) +{ +// control flow +// tests for recognition of loop independent dependences +// between statements in mutually exclusive regions. + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D-1; ++i) { + if (b[i] < (real_t)0.) { + goto L20; + } + a[i] = c[i] + d[i] * e[i]; + goto L10; +L20: + c[i+1] = a[i] + d[i] * d[i]; +L10: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c new file mode 100644 index 00000000000..d1401e9f915 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s162 (int k) +{ +// control flow +// deriving assertions + + for (int nl = 0; nl < iterations; nl++) { + if (k > 0) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = a[i + k] + b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c new file mode 100644 index 00000000000..fa2b47d07eb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s171 (int inc) +{ +// symbolics +// symbolic dependence tests + + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i * inc] += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c new file mode 100644 index 00000000000..304e1f0ec68 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int a;int b;}; + +void s172 (struct arg *x) +{ +// symbolics +// vectorizable if n3 .ne. 0 + + int n1 = x->a; + int n3 = x->b; + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = n1-1; i < LEN_1D; i += n3) { + a[i] += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c new file mode 100644 index 00000000000..d1e4b2a560f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s173 (void) +{ +// symbolics +// expression in loop bounds and subscripts + + + int k = LEN_1D/2; + for (int nl = 0; nl < 10*iterations; nl++) { + for (int i = 0; i < LEN_1D/2; i++) { + a[i+k] = a[i] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c new file mode 100644 index 00000000000..0de5ba73af8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s174 (int M) +{ +// symbolics +// loop with subscript that may seem ambiguous + + for (int nl = 0; nl < 10*iterations; nl++) { + for (int i = 0; i < M; i++) { + a[i+M] = a[i] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c new file mode 100644 index 00000000000..c16a22b4dac --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s175 (int inc) +{ +// symbolics +// symbolic dependence tests + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i += inc) { + a[i] = a[i + inc] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c new file mode 100644 index 00000000000..0d89a941cac --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s176 (void) +{ +// symbolics +// convolution + + + int m = LEN_1D/2; + for (int nl = 0; nl < 4*(iterations/LEN_1D); nl++) { + for (int j = 0; j < (LEN_1D/2); j++) { + for (int i = 0; i < m; i++) { + a[i] += b[i+m-j-1] * c[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c new file mode 100644 index 00000000000..a71e3e3837f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2101 (void) +{ +// diagonals +// main diagonal calculation +// jump in data access + + + for (int nl = 0; nl < 10*iterations; nl++) { + for (int i = 0; i < LEN_2D; i++) { + aa[i][i] += bb[i][i] * cc[i][i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c new file mode 100644 index 00000000000..bf2cebd9fdc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2102 (void) +{ +// diagonals +// identity matrix, best results vectorize both inner and outer loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[j][i] = (real_t)0.; + } + aa[i][i] = (real_t)1.; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c new file mode 100644 index 00000000000..178d6c4f7aa --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s211 (void) +{ +// statement reordering +// statement reordering allows vectorization + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D-1; i++) { + a[i] = b[i - 1] + c[i] * d[i]; + b[i] = b[i + 1] - e[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c new file mode 100644 index 00000000000..25014f029f5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2111 (void) +{ +// wavefronts, it will make jump in data access + + + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + for (int j = 1; j < LEN_2D; j++) { + for (int i = 1; i < LEN_2D; i++) { + aa[j][i] = (aa[j][i-1] + aa[j-1][i])/1.9; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c new file mode 100644 index 00000000000..3ab27b7fe1e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s212 (void) +{ +// statement reordering +// dependency needing temporary + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] *= c[i]; + b[i] += a[i + 1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c new file mode 100644 index 00000000000..dbd11eb8c9a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s221 (void) +{ +// loop distribution +// loop that is partially recursive + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] += c[i] * d[i]; + b[i] = b[i - 1] + a[i] + d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c new file mode 100644 index 00000000000..cd8f9415d3e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s222 (void) +{ +// loop distribution +// partial loop vectorizatio recurrence in middle + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] += b[i] * c[i]; + e[i] = e[i - 1] * e[i - 1]; + a[i] -= b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c new file mode 100644 index 00000000000..b19a548f9c4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2233 (void) +{ +// loop interchange +// interchanging with one of two inner loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + cc[j][i]; + } + for (int j = 1; j < LEN_2D; j++) { + bb[i][j] = bb[i-1][j] + cc[i][j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c new file mode 100644 index 00000000000..85eda0b02c4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2244 (void) +{ +// node splitting +// cycle with ture and anti dependency + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i+1] = b[i] + e[i]; + a[i] = b[i] + c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c new file mode 100644 index 00000000000..1b5a5d1cae5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2251 (void) +{ +// scalar and array expansion +// scalar expansion + + + for (int nl = 0; nl < iterations; nl++) { + real_t s = (real_t)0.0; + for (int i = 0; i < LEN_1D; i++) { + a[i] = s*e[i]; + s = b[i]+c[i]; + b[i] = a[i]+d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c new file mode 100644 index 00000000000..431a60cdb4a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2275 (void) +{ +// loop distribution is needed to be able to interchange + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + aa[j][i] = aa[j][i] + bb[j][i] * cc[j][i]; + } + a[i] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c new file mode 100644 index 00000000000..a6c4f1ba849 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s231 (void) +{ +// loop interchange +// loop with data dependency + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; ++i) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j - 1][i] + bb[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c new file mode 100644 index 00000000000..59e19a403f8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s232 (void) +{ +// loop interchange +// interchanging of triangular loops + + + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + for (int j = 1; j < LEN_2D; j++) { + for (int i = 1; i <= j; i++) { + aa[j][i] = aa[j][i-1]*aa[j][i-1]+bb[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c new file mode 100644 index 00000000000..97a931d2c90 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s233 (void) +{ +// loop interchange +// interchanging with one of two inner loops + + + for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + cc[j][i]; + } + for (int j = 1; j < LEN_2D; j++) { + bb[j][i] = bb[j][i-1] + cc[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c new file mode 100644 index 00000000000..41e089d5695 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s235 (void) +{ +// loop interchanging +// imperfectly nested loops + + + for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + a[i] += b[i] * c[i]; + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + bb[j][i] * a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c new file mode 100644 index 00000000000..286bcbafdd1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s241 (void) +{ +// node splitting +// preloading necessary to allow vectorization + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = b[i] * c[i ] * d[i]; + b[i] = a[i] * a[i+1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c new file mode 100644 index 00000000000..d472127136e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{real_t a;real_t b;}; + +void s242 (struct arg *x) +{ +// node splitting + + real_t s1 = x->a; + real_t s2 = x->b; + + + for (int nl = 0; nl < iterations/5; nl++) { + for (int i = 1; i < LEN_1D; ++i) { + a[i] = a[i - 1] + s1 + s2 + b[i] + c[i] + d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c new file mode 100644 index 00000000000..5e9276d84b2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s243 (void) +{ +// node splitting +// false dependence cycle breaking + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + a[i] = b[i] + c[i ] * d[i]; + b[i] = a[i] + d[i ] * e[i]; + a[i] = b[i] + a[i+1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c new file mode 100644 index 00000000000..19882a92418 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s244 (void) +{ +// node splitting +// false dependence cycle breaking + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; ++i) { + a[i] = b[i] + c[i] * d[i]; + b[i] = c[i] + b[i]; + a[i+1] = b[i] + a[i+1] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c new file mode 100644 index 00000000000..3767f489cce --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s251 (void) +{ +// scalar and array expansion +// scalar expansion + + + real_t s; + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + s = b[i] + c[i] * d[i]; + a[i] = s * s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c new file mode 100644 index 00000000000..86ca64cc3af --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s252 (void) +{ +// scalar and array expansion +// loop with ambiguous scalar temporary + + + real_t t, s; + for (int nl = 0; nl < iterations; nl++) { + t = (real_t) 0.; + for (int i = 0; i < LEN_1D; i++) { + s = b[i] * c[i]; + a[i] = s + t; + t = s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c new file mode 100644 index 00000000000..8bc20ff6bfd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s253 (void) +{ +// scalar and array expansion +// scalar expansio assigned under if + + + real_t s; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > b[i]) { + s = a[i] - b[i] * d[i]; + c[i] += s; + a[i] = s; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c new file mode 100644 index 00000000000..75c1f9b5a12 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s254 (void) +{ +// scalar and array expansion +// carry around variable + + + real_t x; + for (int nl = 0; nl < 4*iterations; nl++) { + x = b[LEN_1D-1]; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + x) * (real_t).5; + x = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c new file mode 100644 index 00000000000..bc024b316ee --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s255 (void) +{ +// scalar and array expansion +// carry around variables, 2 levels + + + real_t x, y; + for (int nl = 0; nl < iterations; nl++) { + x = b[LEN_1D-1]; + y = b[LEN_1D-2]; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + x + y) * (real_t).333; + y = x; + x = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c new file mode 100644 index 00000000000..97317a79052 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s256 (void) +{ +// scalar and array expansion +// array expansion + + + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + for (int j = 1; j < LEN_2D; j++) { + a[j] = (real_t)1.0 - a[j - 1]; + aa[j][i] = a[j] + bb[j][i]*d[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c new file mode 100644 index 00000000000..efa0e48b390 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s257 (void) +{ +// scalar and array expansion +// array expansion + + + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + for (int i = 1; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + a[i] = aa[j][i] - a[i-1]; + aa[j][i] = a[i] + bb[j][i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c new file mode 100644 index 00000000000..bae9e8ca529 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s258 (void) +{ +// scalar and array expansion +// wrap-around scalar under an if + + + real_t s; + for (int nl = 0; nl < iterations; nl++) { + s = 0.; + for (int i = 0; i < LEN_2D; ++i) { + if (a[i] > 0.) { + s = d[i] * d[i]; + } + b[i] = s * c[i] + d[i]; + e[i] = (s + (real_t)1.) * aa[0][i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c new file mode 100644 index 00000000000..36102e78d22 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s261 (void) +{ +// scalar and array expansion +// wrap-around scalar under an if + + + real_t t; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D; ++i) { + t = a[i] + b[i]; + a[i] = t + c[i-1]; + t = c[i] * d[i]; + c[i] = t; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c new file mode 100644 index 00000000000..01da7cd73c2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s271 (void) +{ +// control flow +// loop with singularity handling + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + a[i] += b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c new file mode 100644 index 00000000000..c5df5fae63f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c @@ -0,0 +1,32 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2710 (int x) +{ +// control flow +// scalar and vector ifs + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > b[i]) { + a[i] += b[i] * d[i]; + if (LEN_1D > 10) { + c[i] += d[i] * d[i]; + } else { + c[i] = d[i] * e[i] + (real_t)1.; + } + } else { + b[i] = a[i] + e[i] * e[i]; + if (x > (real_t)0.) { + c[i] = a[i] + d[i] * d[i]; + } else { + c[i] += e[i] * e[i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c new file mode 100644 index 00000000000..23a85fa800f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2711 (void) +{ +// control flow +// semantic if removal + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (b[i] != (real_t)0.0) { + a[i] += b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c new file mode 100644 index 00000000000..ea60a9acdc5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s2712 (void) +{ +// control flow +// if to elemental min + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > b[i]) { + a[i] += b[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c new file mode 100644 index 00000000000..a44525a39a7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s272 (int t) +{ +// control flow +// loop with independent conditional + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (e[i] >= t) { + a[i] += c[i] * d[i]; + b[i] += c[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c new file mode 100644 index 00000000000..305a10f6c10 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s273 (void) +{ +// control flow +// simple loop with dependent conditional + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += d[i] * e[i]; + if (a[i] < (real_t)0.) + b[i] += d[i] * e[i]; + c[i] += a[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c new file mode 100644 index 00000000000..469f89b29a0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s274 (void) +{ +// control flow +// complex loop with dependent conditional + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = c[i] + e[i] * d[i]; + if (a[i] > (real_t)0.) { + b[i] = a[i] + b[i]; + } else { + a[i] = d[i] * e[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c new file mode 100644 index 00000000000..99a154134fb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s275 (void) +{ +// control flow +// if around inner loop, interchanging needed + + + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + for (int i = 0; i < LEN_2D; i++) { + if (aa[0][i] > (real_t)0.) { + for (int j = 1; j < LEN_2D; j++) { + aa[j][i] = aa[j-1][i] + bb[j][i] * cc[j][i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c new file mode 100644 index 00000000000..9341aeedf0d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s276 (void) +{ +// control flow +// if test using loop index + + + int mid = (LEN_1D/2); + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (i+1 < mid) { + a[i] += b[i] * c[i]; + } else { + a[i] += b[i] * d[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c new file mode 100644 index 00000000000..6bcebeb8587 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s277 (void) +{ +// control flow +// test for dependences arising from guard variable computation. + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++) { + if (a[i] >= (real_t)0.) { + goto L20; + } + if (b[i] >= (real_t)0.) { + goto L30; + } + a[i] += c[i] * d[i]; +L30: + b[i+1] = c[i] + d[i] * e[i]; +L20: +; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c new file mode 100644 index 00000000000..6e013b8621f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s278 (void) +{ +// control flow +// if/goto to block if-then-else + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + goto L20; + } + b[i] = -b[i] + d[i] * e[i]; + goto L30; +L20: + c[i] = -c[i] + d[i] * e[i]; +L30: + a[i] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c new file mode 100644 index 00000000000..391179b9863 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s279 (void) +{ +// control flow +// vector if/gotos + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + goto L20; + } + b[i] = -b[i] + d[i] * d[i]; + if (b[i] <= a[i]) { + goto L30; + } + c[i] += d[i] * e[i]; + goto L30; +L20: + c[i] = -c[i] + e[i] * e[i]; +L30: + a[i] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c new file mode 100644 index 00000000000..34a122ada05 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s281 (void) +{ +// crossing thresholds +// index set splitting +// reverse data access + + + real_t x; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + x = a[LEN_1D-i-1] + b[i] * c[i]; + a[i] = x-(real_t)1.0; + b[i] = x; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c new file mode 100644 index 00000000000..2d8d42e44c3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s291 (void) +{ +// loop peeling +// wrap around variable, 1 level + + + int im1; + for (int nl = 0; nl < 2*iterations; nl++) { + im1 = LEN_1D-1; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + b[im1]) * (real_t).5; + im1 = i; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c new file mode 100644 index 00000000000..aa4fe8a76a9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s292 (void) +{ +// loop peeling +// wrap around variable, 2 levels +// similar to S291 + + + int im1, im2; + for (int nl = 0; nl < iterations; nl++) { + im1 = LEN_1D-1; + im2 = LEN_1D-2; + for (int i = 0; i < LEN_1D; i++) { + a[i] = (b[i] + b[im1] + b[im2]) * (real_t).333; + im2 = im1; + im1 = i; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c new file mode 100644 index 00000000000..37c97bae475 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s293 (void) +{ +// loop peeling +// a(i)=a(0) with actual dependence cycle, loop is vectorizable + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[0]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c new file mode 100644 index 00000000000..bd5f4a821e1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s311 (void) +{ +// reductions +// sum reduction + + + real_t sum; + for (int nl = 0; nl < iterations*10; nl++) { + sum = (real_t)0.; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c new file mode 100644 index 00000000000..8fe8bbc1714 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c @@ -0,0 +1,32 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3110 (void) +{ +// reductions +// if to max with index reductio 2 dimensions +// similar to S315 + + + int xindex, yindex; + real_t max, chksum; + for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) { + max = aa[(0)][0]; + xindex = 0; + yindex = 0; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + if (aa[i][j] > max) { + max = aa[i][j]; + xindex = i; + yindex = j; + } + } + } + chksum = max + (real_t) xindex + (real_t) yindex; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c new file mode 100644 index 00000000000..dee8f973f3f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3111 (void) +{ +// reductions +// conditional sum reduction + + + real_t sum; + for (int nl = 0; nl < iterations/2; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + sum += a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c new file mode 100644 index 00000000000..f9d1004f2c8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c @@ -0,0 +1,35 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t test(real_t* A){ + real_t s = (real_t)0.0; + for (int i = 0; i < 4; i++) + s += A[i]; + return s; +} + +void s31111 (void) +{ +// reductions +// sum reduction + + + real_t sum; + for (int nl = 0; nl < 2000*iterations; nl++) { + sum = (real_t)0.; + sum += test(a); + sum += test(&a[4]); + sum += test(&a[8]); + sum += test(&a[12]); + sum += test(&a[16]); + sum += test(&a[20]); + sum += test(&a[24]); + sum += test(&a[28]); + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c new file mode 100644 index 00000000000..dbc517af16c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3112 (void) +{ +// reductions +// sum reduction saving running sums + + + real_t sum; + for (int nl = 0; nl < iterations; nl++) { + sum = (real_t)0.0; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i]; + b[i] = sum; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c new file mode 100644 index 00000000000..96e23ed2f7d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3113 (void) +{ +// reductions +// maximum of absolute value + + + real_t max; + for (int nl = 0; nl < iterations*4; nl++) { + max = ABS(a[0]); + for (int i = 0; i < LEN_1D; i++) { + if ((ABS(a[i])) > max) { + max = ABS(a[i]); + } + } + dummy(a, b, c, d, e, aa, bb, cc, max); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c new file mode 100644 index 00000000000..71854570e14 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s312 (void) +{ +// reductions +// product reduction + + + real_t prod; + for (int nl = 0; nl < 10*iterations; nl++) { + prod = (real_t)1.; + for (int i = 0; i < LEN_1D; i++) { + prod *= a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, prod); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c new file mode 100644 index 00000000000..c3a4edb4c92 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s313 (void) +{ +// reductions +// dot product + + + real_t dot; + for (int nl = 0; nl < iterations*5; nl++) { + dot = (real_t)0.; + for (int i = 0; i < LEN_1D; i++) { + dot += a[i] * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, dot); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c new file mode 100644 index 00000000000..2ce23fc5357 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s314 (void) +{ +// reductions +// if to max reduction + + + real_t x; + for (int nl = 0; nl < iterations*5; nl++) { + x = a[0]; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > x) { + x = a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, x); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c new file mode 100644 index 00000000000..d1d80f7458b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s315 (void) +{ +// reductions +// if to max with index reductio 1 dimension + + + for (int i = 0; i < LEN_1D; i++) + a[i] = (i * 7) % LEN_1D; + + real_t x, chksum; + int index; + for (int nl = 0; nl < iterations; nl++) { + x = a[0]; + index = 0; + for (int i = 0; i < LEN_1D; ++i) { + if (a[i] > x) { + x = a[i]; + index = i; + } + } + chksum = x + (real_t) index; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c new file mode 100644 index 00000000000..e16e234f0ea --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s316 (void) +{ +// reductions +// if to min reduction + + + real_t x; + for (int nl = 0; nl < iterations*5; nl++) { + x = a[0]; + for (int i = 1; i < LEN_1D; ++i) { + if (a[i] < x) { + x = a[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, x); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c new file mode 100644 index 00000000000..f7b9c6548f9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s317 (void) +{ +// reductions +// product reductio vectorize with +// 1. scalar expansion of factor, and product reduction +// 2. closed form solution: q = factor**n + + + real_t q; + for (int nl = 0; nl < 5*iterations; nl++) { + q = (real_t)1.; + for (int i = 0; i < LEN_1D/2; i++) { + q *= (real_t).99; + } + dummy(a, b, c, d, e, aa, bb, cc, q); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c new file mode 100644 index 00000000000..b5e4174b7f2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s318 (int inc) +{ +// reductions +// isamax, max absolute value, increments not equal to 1 + + int k, index; + real_t max, chksum; + for (int nl = 0; nl < iterations/2; nl++) { + k = 0; + index = 0; + max = ABS(a[0]); + k += inc; + for (int i = 1; i < LEN_1D; i++) { + if (ABS(a[k]) <= max) { + goto L5; + } + index = i; + max = ABS(a[k]); +L5: + k += inc; + } + chksum = max + (real_t) index; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c new file mode 100644 index 00000000000..023b18beda8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s319 (void) +{ +// reductions +// coupled reductions + + + real_t sum; + for (int nl = 0; nl < 2*iterations; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + a[i] = c[i] + d[i]; + sum += a[i]; + b[i] = c[i] + e[i]; + sum += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c new file mode 100644 index 00000000000..9daeb9e7a0a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s321 (void) +{ +// recurrences +// first order linear recurrence + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] += a[i-1] * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c new file mode 100644 index 00000000000..34058b7dadb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s322 (void) +{ +// recurrences +// second order linear recurrence + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 2; i < LEN_1D; i++) { + a[i] = a[i] + a[i - 1] * b[i] + a[i - 2] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c new file mode 100644 index 00000000000..eb8de5aa833 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s323 (void) +{ +// recurrences +// coupled recurrence + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 1; i < LEN_1D; i++) { + a[i] = b[i-1] + c[i] * d[i]; + b[i] = a[i] + c[i] * e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c new file mode 100644 index 00000000000..434dd536975 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s3251 (void) +{ +// scalar and array expansion +// scalar expansion + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D-1; i++){ + a[i+1] = b[i]+c[i]; + b[i] = c[i]*e[i]; + d[i] = a[i]*e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c new file mode 100644 index 00000000000..2f6e7d3b064 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s331 (void) +{ +// search loops +// if to last-1 + + + int j; + real_t chksum; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] < (real_t)0.) { + j = i; + } + } + chksum = (real_t) j; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c new file mode 100644 index 00000000000..79cbf3d437b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s332 (int t) +{ +// search loops +// first value greater than threshold + + int index; + real_t value; + real_t chksum; + for (int nl = 0; nl < iterations; nl++) { + index = -2; + value = -1.; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > t) { + index = i; + value = a[i]; + goto L20; + } + } +L20: + chksum = value + (real_t) index; + dummy(a, b, c, d, e, aa, bb, cc, chksum); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c new file mode 100644 index 00000000000..b3f5b2332e9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s341 (void) +{ +// packing +// pack positive values +// not vectorizable, value of j in unknown at each iteration + + + int j; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + j++; + a[j] = b[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c new file mode 100644 index 00000000000..72f630ca144 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s342 (void) +{ +// packing +// unpacking +// not vectorizable, value of j in unknown at each iteration + + + int j = 0; + for (int nl = 0; nl < iterations; nl++) { + j = -1; + for (int i = 0; i < LEN_1D; i++) { + if (a[i] > (real_t)0.) { + j++; + a[i] = b[j]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c new file mode 100644 index 00000000000..b4fa1d6cfe2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s343 (void) +{ +// packing +// pack 2-d array into one dimension +// not vectorizable, value of k in unknown at each iteration + + + int k; + for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) { + k = -1; + for (int i = 0; i < LEN_2D; i++) { + for (int j = 0; j < LEN_2D; j++) { + if (bb[j][i] > (real_t)0.) { + k++; + flat_2d_array[k] = aa[j][i]; + } + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c new file mode 100644 index 00000000000..7076e987804 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s351 (void) +{ +// loop rerolling +// unrolled saxpy + + + real_t alpha = c[0]; + for (int nl = 0; nl < 8*iterations; nl++) { + for (int i = 0; i < LEN_1D; i += 5) { + a[i] += alpha * b[i]; + a[i + 1] += alpha * b[i + 1]; + a[i + 2] += alpha * b[i + 2]; + a[i + 3] += alpha * b[i + 3]; + a[i + 4] += alpha * b[i + 4]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c new file mode 100644 index 00000000000..68f81938748 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s352 (void) +{ +// loop rerolling +// unrolled dot product + + + real_t dot; + for (int nl = 0; nl < 8*iterations; nl++) { + dot = (real_t)0.; + for (int i = 0; i < LEN_1D; i += 5) { + dot = dot + a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2] + * b[i + 2] + a[i + 3] * b[i + 3] + a[i + 4] * b[i + 4]; + } + dummy(a, b, c, d, e, aa, bb, cc, dot); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c new file mode 100644 index 00000000000..f4f4c67e9f3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s353 (int * __restrict__ ip) +{ +// loop rerolling +// unrolled sparse saxpy +// gather is required + + real_t alpha = c[0]; + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i += 5) { + a[i] += alpha * b[ip[i]]; + a[i + 1] += alpha * b[ip[i + 1]]; + a[i + 2] += alpha * b[ip[i + 2]]; + a[i + 3] += alpha * b[ip[i + 3]]; + a[i + 4] += alpha * b[ip[i + 4]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c new file mode 100644 index 00000000000..23b1cc799e3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int * __restrict__ a;real_t b;}; + +void s4112 (struct arg *x) +{ +// indirect addressing +// sparse saxpy +// gather is required + + int * __restrict__ ip = x->a; + real_t s = x->b; + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[ip[i]] * s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c new file mode 100644 index 00000000000..feaa64094b1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s4113 (int * __restrict__ ip) +{ +// indirect addressing +// indirect addressing on rhs and lhs +// gather and scatter is required + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[ip[i]] = b[ip[i]] + c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c new file mode 100644 index 00000000000..51a64727d71 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int * __restrict__ a;int b;}; + +void s4114 (struct arg *x) +{ +// indirect addressing +// mix indirect addressing with variable lower and upper bounds +// gather is required + + int * __restrict__ ip = x->a; + int n1 = x->b; + + + int k; + for (int nl = 0; nl < iterations; nl++) { + for (int i = n1-1; i < LEN_1D; i++) { + k = ip[i]; + a[i] = b[i] + c[LEN_1D-k+1-2] * d[i]; + k += 5; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c new file mode 100644 index 00000000000..acd591ebce0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s4115 (int * __restrict__ ip) +{ +// indirect addressing +// sparse dot product +// gather is required + + real_t sum; + for (int nl = 0; nl < iterations; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i] * b[ip[i]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c new file mode 100644 index 00000000000..a07fa90d007 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +struct arg{int * __restrict__ a;int b;int c;}; + +void s4116 (struct arg *x) +{ +// indirect addressing +// more complicated sparse sdot +// gather is required + + int * __restrict__ ip = x->a; + int j = x->b; + int inc = x->c; + + + real_t sum; + int off; + for (int nl = 0; nl < 100*iterations; nl++) { + sum = 0.; + for (int i = 0; i < LEN_2D-1; i++) { + off = inc + i; + sum += a[off] * aa[j-1][ip[i]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c new file mode 100644 index 00000000000..99eba930bfc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s4117 (void) +{ +// indirect addressing +// seq function + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i] + c[i/2] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c new file mode 100644 index 00000000000..d51efd8cbe8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +real_t f(real_t a, real_t b){ + return a*b; +} + +void s4121 (void) +{ +// statement functions +// elementwise multiplication + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += f(b[i],c[i]); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c new file mode 100644 index 00000000000..f5b0b083c26 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s421 (void) +{ +// storage classes and equivalencing +// equivalence- no overlap + + + xx = flat_2d_array; + + for (int nl = 0; nl < 4*iterations; nl++) { + yy = xx; + for (int i = 0; i < LEN_1D - 1; i++) { + xx[i] = yy[i+1] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c new file mode 100644 index 00000000000..2fa69d74593 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s422 (void) +{ +// storage classes and equivalencing +// common and equivalence statement +// anti-dependence, threshold of 4 + + + xx = flat_2d_array + 4; + + for (int nl = 0; nl < 8*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + xx[i] = flat_2d_array[i + 8] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c new file mode 100644 index 00000000000..cc20cb47350 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s423 (void) +{ +// storage classes and equivalencing +// common and equivalenced variables - with anti-dependence + + // do this again here + int vl = 64; + xx = flat_2d_array + vl; + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D - 1; i++) { + flat_2d_array[i+1] = xx[i] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c new file mode 100644 index 00000000000..d5029e632bf --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s424 (void) +{ +// storage classes and equivalencing +// common and equivalenced variables - overlap +// vectorizeable in strips of 64 or less + + // do this again here + int vl = 63; + xx = flat_2d_array + vl; + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D - 1; i++) { + xx[i+1] = flat_2d_array[i] + a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 1.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c new file mode 100644 index 00000000000..ff1e05c4791 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s431 (void) +{ +// parameters +// parameter statement + + int k1=1; + int k2=2; + int k=2*k1-k2; + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[i+k] + b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c new file mode 100644 index 00000000000..b1514f26749 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s441 (void) +{ +// non-logical if's +// arithmetic if + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (d[i] < (real_t)0.) { + a[i] += b[i] * c[i]; + } else if (d[i] == (real_t)0.) { + a[i] += b[i] * b[i]; + } else { + a[i] += c[i] * c[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c new file mode 100644 index 00000000000..209522696e4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c @@ -0,0 +1,37 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s442 (void) +{ +// non-logical if's +// computed goto + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < LEN_1D; i++) { + switch (indx[i]) { + case 1: goto L15; + case 2: goto L20; + case 3: goto L30; + case 4: goto L40; + } +L15: + a[i] += b[i] * b[i]; + goto L50; +L20: + a[i] += c[i] * c[i]; + goto L50; +L30: + a[i] += d[i] * d[i]; + goto L50; +L40: + a[i] += e[i] * e[i]; +L50: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c new file mode 100644 index 00000000000..72b74f0a341 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s443 (void) +{ +// non-logical if's +// arithmetic if + + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (d[i] <= (real_t)0.) { + goto L20; + } else { + goto L30; + } +L20: + a[i] += b[i] * c[i]; + goto L50; +L30: + a[i] += b[i] * b[i]; +L50: + ; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c new file mode 100644 index 00000000000..6fa2160760f --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s451 (void) +{ +// intrinsic functions +// intrinsics + + + for (int nl = 0; nl < iterations/5; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = sinf(b[i]) + cosf(c[i]); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c new file mode 100644 index 00000000000..7a7c4c865ad --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s452 (void) +{ +// intrinsic functions +// seq function + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i] + c[i] * (real_t) (i+1); + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c new file mode 100644 index 00000000000..c2fb559defe --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s453 (void) +{ +// induction varibale recognition + + real_t s; + + + for (int nl = 0; nl < iterations*2; nl++) { + s = 0.; + for (int i = 0; i < LEN_1D; i++) { + s += (real_t)2.; + a[i] = s * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c new file mode 100644 index 00000000000..eb9862762ae --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +int s471s(void) +{ +// -- dummy subroutine call made in s471 + return 0; +} + +void s471 (void) +{ +// call statements + + int m = LEN_1D; + + + for (int nl = 0; nl < iterations/2; nl++) { + for (int i = 0; i < m; i++) { + x[i] = b[i] + d[i] * d[i]; + s471s(); + b[i] = c[i] + d[i] * e[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c new file mode 100644 index 00000000000..ce4e2ccd0af --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s481 (void) +{ +// non-local goto's +// stop statement + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (d[i] < (real_t)0.) { + exit (0); + } + a[i] += b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c new file mode 100644 index 00000000000..f6964a87f62 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s482 (void) +{ +// non-local goto's +// other loop exit with code before exit + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] * c[i]; + if (c[i] > b[i]) break; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c new file mode 100644 index 00000000000..b1b2d1bd1a2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void s491 (int * __restrict__ ip) +{ +// vector semantics +// indirect addressing on lhs, store in sequence +// scatter is required + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[ip[i]] = b[i] + c[i] * d[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c new file mode 100644 index 00000000000..da305554efb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void va (void) +{ +// control loops +// vector assignment + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c new file mode 100644 index 00000000000..2373edf66fc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vag (int * __restrict__ ip) +{ +// control loops +// vector assignment, gather +// gather is required + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = b[ip[i]]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c new file mode 100644 index 00000000000..dd7ff4a0990 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vas (int * __restrict__ ip) +{ +// control loops +// vector assignment, scatter +// scatter is required + + for (int nl = 0; nl < 2*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[ip[i]] = b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c new file mode 100644 index 00000000000..5bfb26662d2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c @@ -0,0 +1,35 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vbor (void) +{ +// control loops +// basic operations rates, isolate arithmetic from memory traffic +// all combinations of three, 59 flops for 6 loads and 1 store. + + + real_t a1, b1, c1, d1, e1, f1; + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_2D; i++) { + a1 = a[i]; + b1 = b[i]; + c1 = c[i]; + d1 = d[i]; + e1 = e[i]; + f1 = aa[0][i]; + a1 = a1 * b1 * c1 + a1 * b1 * d1 + a1 * b1 * e1 + a1 * b1 * f1 + + a1 * c1 * d1 + a1 * c1 * e1 + a1 * c1 * f1 + a1 * d1 * e1 + + a1 * d1 * f1 + a1 * e1 * f1; + b1 = b1 * c1 * d1 + b1 * c1 * e1 + b1 * c1 * f1 + b1 * d1 * e1 + + b1 * d1 * f1 + b1 * e1 * f1; + c1 = c1 * d1 * e1 + c1 * d1 * f1 + c1 * e1 * f1; + d1 = d1 * e1 * f1; + x[i] = a1 * b1 * c1 * d1; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c new file mode 100644 index 00000000000..94059723985 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vdotr (void) +{ +// control loops +// vector dot product reduction + + + real_t dot; + for (int nl = 0; nl < iterations*10; nl++) { + dot = 0.; + for (int i = 0; i < LEN_1D; i++) { + dot += a[i] * b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, dot); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c new file mode 100644 index 00000000000..6714eddbde3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vif (void) +{ +// control loops +// vector if + + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + if (b[i] > (real_t)0.) { + a[i] = b[i]; + } + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c new file mode 100644 index 00000000000..fd313e137a5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpv (void) +{ +// control loops +// vector plus vector + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c new file mode 100644 index 00000000000..a7dcf2beda6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpvpv (void) +{ +// control loops +// vector plus vector plus vector + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] + c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c new file mode 100644 index 00000000000..d0e74e05502 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpvts (real_t s) +{ +// control loops +// vector plus vector times scalar + + for (int nl = 0; nl < iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] * s; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c new file mode 100644 index 00000000000..4124dc5335e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vpvtv (void) +{ +// control loops +// vector plus vector times vector + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] += b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c new file mode 100644 index 00000000000..0ae02939bc8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vsumr (void) +{ +// control loops +// vector sum reduction + + + real_t sum; + for (int nl = 0; nl < iterations*10; nl++) { + sum = 0.; + for (int i = 0; i < LEN_1D; i++) { + sum += a[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, sum); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c new file mode 100644 index 00000000000..07788b4cc0b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vtv (void) +{ +// control loops +// vector times vector + + + for (int nl = 0; nl < iterations*10; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] *= b[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c new file mode 100644 index 00000000000..70e8a5fd56a --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param vect-epilogues-nomask=0" } */ +/* { dg-require-effective-target vect_float } */ + +#include "tsvc.h" + +void vtvtv (void) +{ +// control loops +// vector times vector times vector + + + for (int nl = 0; nl < 4*iterations; nl++) { + for (int i = 0; i < LEN_1D; i++) { + a[i] = a[i] * b[i] * c[i]; + } + dummy(a, b, c, d, e, aa, bb, cc, 0.); + } +} +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ \ No newline at end of file