public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
From: Martin Liska <marxin@gcc.gnu.org>
To: gcc-cvs@gcc.gnu.org
Subject: [gcc(refs/users/marxin/heads/TSVC)] Add TSVC tests.
Date: Fri, 15 Oct 2021 16:32:39 +0000 (GMT) [thread overview]
Message-ID: <20211015163239.659E83857C71@sourceware.org> (raw)
https://gcc.gnu.org/g:b5c327388d6572ed99858d2d48be28db86b4230f
commit b5c327388d6572ed99858d2d48be28db86b4230f
Author: Martin Liska <mliska@suse.cz>
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 <stdlib.h>
+#include <math.h>
+
+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
next reply other threads:[~2021-10-15 16:32 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-10-15 16:32 Martin Liska [this message]
2021-10-18 7:45 Martin Liska
2021-10-18 7:50 Martin Liska
2021-10-18 8:03 Martin Liska
2021-10-18 10:59 Martin Liska
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20211015163239.659E83857C71@sourceware.org \
--to=marxin@gcc.gnu.org \
--cc=gcc-cvs@gcc.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).