diff --git a/gcc/testsuite/gcc.dg/vect/license.txt b/gcc/testsuite/gcc.dg/vect/license.txt
new file mode 100644
index 00000000000..782154d4adf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/license.txt
@@ -0,0 +1,58 @@
+Copyright (c) 2011 University of Illinois at Urbana-Champaign.  All rights reserved.
+
+
+
+Developed by: Polaris Research Group
+
+              University of Illinois at Urbana-Champaign
+
+              http://polaris.cs.uiuc.edu
+
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+
+of this software and associated documentation files (the "Software"), to
+
+deal with the Software without restriction, including without limitation the
+
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+
+sell copies of the Software, and to permit persons to whom the Software is
+
+furnished to do so, subject to the following conditions:
+
+  1. Redistributions of source code must retain the above copyright notice,
+
+     this list of conditions and the following disclaimers.
+
+  2. Redistributions in binary form must reproduce the above copyright
+
+     notice, this list of conditions and the following disclaimers in the
+
+     documentation and/or other materials provided with the distribution.
+
+  3. Neither the names of Polaris Research Group, University of Illinois at
+
+     Urbana-Champaign, nor the names of its contributors may be used to endorse
+
+     or promote products derived from this Software without specific prior
+
+     written permission.
+
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+
+WITH THE SOFTWARE.
+
diff --git a/gcc/testsuite/gcc.dg/vect/tsvc.h b/gcc/testsuite/gcc.dg/vect/tsvc.h
new file mode 100644
index 00000000000..cfc00cba0c5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/tsvc.h
@@ -0,0 +1,25 @@
+#define iterations 100000
+#define LEN_1D 32000
+#define LEN_2D 256
+#define ARRAY_ALIGNMENT 64
+
+#include <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..c6c57404757
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s000 (void)
+{
+//    linear dependence testing
+//    no dependence - vectorizable
+
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = b[i] + 1;
+        }
+        dummy((real_t*)a, (real_t*)b, (real_t*)c, (real_t*)d, (real_t*)e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c
new file mode 100644
index 00000000000..b63fb6ddaf7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s111 (void)
+{
+//    linear dependence testing
+//    no dependence - vectorizable
+
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 1; i < LEN_1D; i += 2) {
+            a[i] = a[i - 1] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c
new file mode 100644
index 00000000000..e7c5a75424b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1111 (void)
+{
+//    no dependence - vectorizable
+//    jump in data access
+
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D/2; i++) {
+            a[2*i] = c[i] * b[i] + d[i] * b[i] + c[i] * c[i] + d[i] * b[i] + d[i] * c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c
new file mode 100644
index 00000000000..80e8a71b543
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1112 (void)
+{
+//    linear dependence testing
+//    loop reversal
+
+
+    for (int nl = 0; nl < iterations*3; nl++) {
+        for (int i = LEN_1D - 1; i >= 0; i--) {
+            a[i] = b[i] + (real_t) 1.;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c
new file mode 100644
index 00000000000..c26ac752230
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1113 (void)
+{
+//    linear dependence testing
+//    one iteration dependency on a(LEN_1D/2) but still vectorizable
+
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = a[LEN_1D/2] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c
new file mode 100644
index 00000000000..cf1ace4b4da
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1115 (void)
+{
+//    linear dependence testing
+//    triangular saxpy loop
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                aa[i][j] = aa[i][j]*cc[j][i] + bb[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c
new file mode 100644
index 00000000000..61a531907b9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1119 (void)
+{
+//    linear dependence testing
+//    no dependence - vectorizable
+
+
+    for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) {
+        for (int i = 1; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                aa[i][j] = aa[i-1][j] + bb[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c
new file mode 100644
index 00000000000..9025825ef94
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s112 (void)
+{
+//    linear dependence testing
+//    loop reversal
+
+
+    for (int nl = 0; nl < 3*iterations; nl++) {
+        for (int i = LEN_1D - 2; i >= 0; i--) {
+            a[i+1] = a[i] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c
new file mode 100644
index 00000000000..4cdb8c0edeb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s113 (void)
+{
+//    linear dependence testing
+//    a(i)=a(1) but no actual dependence cycle
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 1; i < LEN_1D; i++) {
+            a[i] = a[0] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c
new file mode 100644
index 00000000000..f532c95421e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s114 (void)
+{
+//    linear dependence testing
+//    transpose vectorization
+//    Jump in data access - not vectorizable
+
+
+    for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < i; j++) {
+                aa[i][j] = aa[j][i] + bb[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c
new file mode 100644
index 00000000000..75f1c4e72dd
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s115 (void)
+{
+//    linear dependence testing
+//    triangular saxpy loop
+
+
+    for (int nl = 0; nl < 1000*(iterations/LEN_2D); nl++) {
+        for (int j = 0; j < LEN_2D; j++) {
+            for (int i = j+1; i < LEN_2D; i++) {
+                a[i] -= aa[j][i] * a[j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c
new file mode 100644
index 00000000000..3806e87e16b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s116 (void)
+{
+//    linear dependence testing
+
+
+    for (int nl = 0; nl < iterations*10; nl++) {
+        for (int i = 0; i < LEN_1D - 5; i += 5) {
+            a[i] = a[i + 1] * a[i];
+            a[i + 1] = a[i + 2] * a[i + 1];
+            a[i + 2] = a[i + 3] * a[i + 2];
+            a[i + 3] = a[i + 4] * a[i + 3];
+            a[i + 4] = a[i + 5] * a[i + 4];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c
new file mode 100644
index 00000000000..7a3303f87e3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c
@@ -0,0 +1,31 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1161 (void)
+{
+//    control flow
+//    tests for recognition of loop independent dependences
+//    between statements in mutually exclusive regions.
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; ++i) {
+            if (c[i] < (real_t)0.) {
+                goto L20;
+            }
+            a[i] = c[i] + d[i] * e[i];
+            goto L10;
+L20:
+            b[i] = a[i] + d[i] * d[i];
+L10:
+            ;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c
new file mode 100644
index 00000000000..290839919da
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s118 (void)
+{
+//    linear dependence testing
+//    potential dot product recursion
+
+
+    for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) {
+        for (int i = 1; i < LEN_2D; i++) {
+            for (int j = 0; j <= i - 1; j++) {
+                a[i] += bb[j][i] * a[i-j-1];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c
new file mode 100644
index 00000000000..2b98fa5467f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s119 (void)
+{
+//    linear dependence testing
+//    no dependence - vectorizable
+
+
+    for (int nl = 0; nl < 200*(iterations/(LEN_2D)); nl++) {
+        for (int i = 1; i < LEN_2D; i++) {
+            for (int j = 1; j < LEN_2D; j++) {
+                aa[i][j] = aa[i-1][j-1] + bb[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c
new file mode 100644
index 00000000000..f8d1cc055cd
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s121 (void)
+{
+//    induction variable recognition
+//    loop with possible ambiguity because of scalar store
+
+
+    int j;
+    for (int nl = 0; nl < 3*iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+            j = i + 1;
+            a[i] = a[j] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c
new file mode 100644
index 00000000000..ad103d0fe59
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1213 (void)
+{
+//    statement reordering
+//    dependency needing temporary
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 1; i < LEN_1D-1; i++) {
+            a[i] = b[i-1]+c[i];
+            b[i] = a[i+1]*d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c
new file mode 100644
index 00000000000..e8d294b9f92
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c
@@ -0,0 +1,32 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+struct arg{int a;int b;};
+
+void s122 (struct arg *x)
+{
+//    induction variable recognition
+//    variable lower and upper bound, and stride
+//    reverse data access and jump in data access
+
+    int n1 = x->a;
+    int n3 = x->b;
+
+
+    int j, k;
+    for (int nl = 0; nl < iterations; nl++) {
+        j = 1;
+        k = 0;
+        for (int i = n1-1; i < LEN_1D; i += n3) {
+            k += j;
+            a[i] += b[LEN_1D - k];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c
new file mode 100644
index 00000000000..7992a65aae5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1221 (void)
+{
+//    run-time symbolic resolution
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 4; i < LEN_1D; i++) {
+            b[i] = b[i - 4] + a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c
new file mode 100644
index 00000000000..f17d5913a54
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c
@@ -0,0 +1,30 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s123 (void)
+{
+//    induction variable recognition
+//    induction variable under an if
+//    not vectorizable, the condition cannot be speculated
+
+
+    int j;
+    for (int nl = 0; nl < iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < (LEN_1D/2); i++) {
+            j++;
+            a[j] = b[i] + d[i] * e[i];
+            if (c[i] > (real_t)0.) {
+                j++;
+                a[j] = c[i] + d[i] * e[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c
new file mode 100644
index 00000000000..128804aed75
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1232 (void)
+{
+//    loop interchange
+//    interchanging of triangular loops
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int j = 0; j < LEN_2D; j++) {
+            for (int i = j; i < LEN_2D; i++) {
+                aa[i][j] = bb[i][j] + cc[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c
new file mode 100644
index 00000000000..4a23eeadbcf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c
@@ -0,0 +1,30 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s124 (void)
+{
+//    induction variable recognition
+//    induction variable under both sides of if (same value)
+
+
+    int j;
+    for (int nl = 0; nl < iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < LEN_1D; i++) {
+            if (b[i] > (real_t)0.) {
+                j++;
+                a[j] = b[i] + d[i] * e[i];
+            } else {
+                j++;
+                a[j] = c[i] + d[i] * e[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c
new file mode 100644
index 00000000000..add25a328eb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1244 (void)
+{
+//    node splitting
+//    cycle with ture and anti dependency
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+            a[i] = b[i] + c[i] * c[i] + b[i]*b[i] + c[i];
+            d[i] = a[i] + a[i+1];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c
new file mode 100644
index 00000000000..871154c3786
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s125 (void)
+{
+//    induction variable recognition
+//    induction variable in two loops; collapsing possible
+
+
+    int k;
+    for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) {
+        k = -1;
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                k++;
+                flat_2d_array[k] = aa[i][j] + bb[i][j] * cc[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c
new file mode 100644
index 00000000000..a6cc3a42e1d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1251 (void)
+{
+//    scalar and array expansion
+//    scalar expansion
+
+
+    real_t s;
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            s = b[i]+c[i];
+            b[i] = a[i]+d[i];
+            a[i] = s*e[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c
new file mode 100644
index 00000000000..011e5ce08e5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s126 (void)
+{
+//    induction variable recognition
+//    induction variable in two loops; recurrence in inner loop
+
+
+    int k;
+    for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) {
+        k = 1;
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 1; j < LEN_2D; j++) {
+                bb[j][i] = bb[j-1][i] + flat_2d_array[k-1] * cc[j][i];
+                ++k;
+            }
+            ++k;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c
new file mode 100644
index 00000000000..b1cd4f99eff
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s127 (void)
+{
+//    induction variable recognition
+//    induction variable with multiple increments
+
+
+    int j;
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < LEN_1D/2; i++) {
+            j++;
+            a[j] = b[i] + c[i] * d[i];
+            j++;
+            a[j] = b[i] + d[i] * e[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c
new file mode 100644
index 00000000000..90cd2cec47b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1279 (void)
+{
+//    control flow
+//    vector if/gotos
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] < (real_t)0.) {
+                if (b[i] > a[i]) {
+                    c[i] += d[i] * e[i];
+                }
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c
new file mode 100644
index 00000000000..3356b16fe1e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c
@@ -0,0 +1,29 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s128 (void)
+{
+//    induction variables
+//    coupled induction variables
+//    jump in data access
+
+
+    int j, k;
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < LEN_1D/2; i++) {
+            k = j + 1;
+            a[i] = b[k] - d[i];
+            j = k + 1;
+            b[k] = a[i] + c[k];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c
new file mode 100644
index 00000000000..8534b71a1a4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1281 (void)
+{
+//    crossing thresholds
+//    index set splitting
+//    reverse data access
+
+
+    real_t x;
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            x = b[i]*c[i] + a[i]*d[i] + e[i];
+            a[i] = x-(real_t)1.0;
+            b[i] = x;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c
new file mode 100644
index 00000000000..377b841d298
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s131 (void)
+{
+//    global data flow analysis
+//    forward substitution
+
+
+    int m  = 1;
+    for (int nl = 0; nl < 5*iterations; nl++) {
+        for (int i = 0; i < LEN_1D - 1; i++) {
+            a[i] = a[i + m] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c
new file mode 100644
index 00000000000..efc3b61d7e1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c
@@ -0,0 +1,34 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s13110 (void)
+{
+//    reductions
+//    if to max with index reductio 2 dimensions
+
+
+    int xindex, yindex;
+    real_t max, chksum;
+    for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) {
+        max = aa[(0)][0];
+        xindex = 0;
+        yindex = 0;
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                if (aa[i][j] > max) {
+                    max = aa[i][j];
+                    xindex = i;
+                    yindex = j;
+                }
+            }
+        }
+        chksum = max + (real_t) xindex + (real_t) yindex;
+        dummy(a, b, c, d, e, aa, bb, cc, chksum);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c
new file mode 100644
index 00000000000..1837e11aa2c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s132 (void)
+{
+//    global data flow analysis
+//    loop with multiple dimension ambiguous subscripts
+
+
+    int m = 0;
+    int j = m;
+    int k = m+1;
+    for (int nl = 0; nl < 400*iterations; nl++) {
+        for (int i= 1; i < LEN_2D; i++) {
+            aa[j][i] = aa[k][i-1] + b[i] * c[1];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c
new file mode 100644
index 00000000000..fddaefb8e66
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1351 (void)
+{
+//    induction pointer recognition
+
+
+    for (int nl = 0; nl < 8*iterations; nl++) {
+        real_t* __restrict__ A = a;
+        real_t* __restrict__ B = b;
+        real_t* __restrict__ C = c;
+        for (int i = 0; i < LEN_1D; i++) {
+            *A = *B+*C;
+            A++;
+            B++;
+            C++;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c
new file mode 100644
index 00000000000..9ea1df48331
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s141 (void)
+{
+//    nonlinear dependence testing
+//    walk a row in a symmetric packed array
+//    element a(i,j) for (int j>i) stored in location j*(j-1)/2+i
+
+
+    int k;
+    for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            k = (i+1) * ((i+1) - 1) / 2 + (i+1)-1;
+            for (int j = i; j < LEN_2D; j++) {
+                flat_2d_array[k] += bb[j][i];
+                k += j+1;
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c
new file mode 100644
index 00000000000..947e761f869
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s1421 (void)
+{
+//    storage classes and equivalencing
+//    equivalence- no overlap
+
+
+    xx = &b[LEN_1D/2];
+
+    for (int nl = 0; nl < 8*iterations; nl++) {
+        for (int i = 0; i < LEN_1D/2; i++) {
+            b[i] = xx[i] + a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c
new file mode 100644
index 00000000000..f04bdfa6c8c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c
@@ -0,0 +1,29 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s151s(real_t a[LEN_1D], real_t b[LEN_1D],  int m)
+{
+    for (int i = 0; i < LEN_1D-1; i++) {
+        a[i] = a[i + m] + b[i];
+    }
+}
+
+void s151 (void)
+{
+//    interprocedural data flow analysis
+//    passing parameter information into a subroutine
+
+
+    for (int nl = 0; nl < 5*iterations; nl++) {
+        s151s(a, b,  1);
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c
new file mode 100644
index 00000000000..6ad1eb3a632
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c
@@ -0,0 +1,30 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s152s(real_t a[LEN_1D], real_t b[LEN_1D], real_t c[LEN_1D], int i)
+{
+    a[i] += b[i] * c[i];
+}
+
+void s152 (void)
+{
+//    interprocedural data flow analysis
+//    collecting information from a subroutine
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            b[i] = d[i] * e[i];
+            s152s(a, b, c, i);
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c
new file mode 100644
index 00000000000..4bfa9a490ef
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c
@@ -0,0 +1,31 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s161 (void)
+{
+//    control flow
+//    tests for recognition of loop independent dependences
+//    between statements in mutually exclusive regions.
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 0; i < LEN_1D-1; ++i) {
+            if (b[i] < (real_t)0.) {
+                goto L20;
+            }
+            a[i] = c[i] + d[i] * e[i];
+            goto L10;
+L20:
+            c[i+1] = a[i] + d[i] * d[i];
+L10:
+            ;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c
new file mode 100644
index 00000000000..60f86fc61d9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s162 (int k)
+{
+//    control flow
+//    deriving assertions
+
+    for (int nl = 0; nl < iterations; nl++) {
+        if (k > 0) {
+            for (int i = 0; i < LEN_1D-1; i++) {
+                a[i] = a[i + k] + b[i] * c[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c
new file mode 100644
index 00000000000..dd2e425ee20
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s171 (int inc)
+{
+//    symbolics
+//    symbolic dependence tests
+
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i * inc] += b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c
new file mode 100644
index 00000000000..a15355fcb64
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+struct arg{int a;int b;};
+
+void s172 (struct arg *x)
+{
+//    symbolics
+//    vectorizable if n3 .ne. 0
+
+    int n1 = x->a;
+    int n3 = x->b;
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = n1-1; i < LEN_1D; i += n3) {
+            a[i] += b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c
new file mode 100644
index 00000000000..def1c4eb22d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s173 (void)
+{
+//    symbolics
+//    expression in loop bounds and subscripts
+
+
+    int k = LEN_1D/2;
+    for (int nl = 0; nl < 10*iterations; nl++) {
+        for (int i = 0; i < LEN_1D/2; i++) {
+            a[i+k] = a[i] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c
new file mode 100644
index 00000000000..f0488fded38
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s174 (int M)
+{
+//    symbolics
+//    loop with subscript that may seem ambiguous
+
+    for (int nl = 0; nl < 10*iterations; nl++) {
+        for (int i = 0; i < M; i++) {
+            a[i+M] = a[i] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c
new file mode 100644
index 00000000000..82825d0a27a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c
@@ -0,0 +1,21 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s175 (int inc)
+{
+//    symbolics
+//    symbolic dependence tests
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i += inc) {
+            a[i] = a[i + inc] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c
new file mode 100644
index 00000000000..f7b79b5ee43
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s176 (void)
+{
+//    symbolics
+//    convolution
+
+
+    int m = LEN_1D/2;
+    for (int nl = 0; nl < 4*(iterations/LEN_1D); nl++) {
+        for (int j = 0; j < (LEN_1D/2); j++) {
+            for (int i = 0; i < m; i++) {
+                a[i] += b[i+m-j-1] * c[j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c
new file mode 100644
index 00000000000..22d298925af
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2101 (void)
+{
+//    diagonals
+//    main diagonal calculation
+//    jump in data access
+
+
+    for (int nl = 0; nl < 10*iterations; nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            aa[i][i] += bb[i][i] * cc[i][i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c
new file mode 100644
index 00000000000..6d243b3b389
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2102 (void)
+{
+//    diagonals
+//    identity matrix, best results vectorize both inner and outer loops
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                aa[j][i] = (real_t)0.;
+            }
+            aa[i][i] = (real_t)1.;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c
new file mode 100644
index 00000000000..51724c75688
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s211 (void)
+{
+//    statement reordering
+//    statement reordering allows vectorization
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 1; i < LEN_1D-1; i++) {
+            a[i] = b[i - 1] + c[i] * d[i];
+            b[i] = b[i + 1] - e[i] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c
new file mode 100644
index 00000000000..296087c84f9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2111 (void)
+{
+//    wavefronts, it will make jump in data access
+
+
+    for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) {
+        for (int j = 1; j < LEN_2D; j++) {
+            for (int i = 1; i < LEN_2D; i++) {
+                aa[j][i] = (aa[j][i-1] + aa[j-1][i])/1.9;
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c
new file mode 100644
index 00000000000..54f54860527
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s212 (void)
+{
+//    statement reordering
+//    dependency needing temporary
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+            a[i] *= c[i];
+            b[i] += a[i + 1] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c
new file mode 100644
index 00000000000..04cc2cc3e18
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s221 (void)
+{
+//    loop distribution
+//    loop that is partially recursive
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 1; i < LEN_1D; i++) {
+            a[i] += c[i] * d[i];
+            b[i] = b[i - 1] + a[i] + d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c
new file mode 100644
index 00000000000..9c9e78ea154
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s222 (void)
+{
+//    loop distribution
+//    partial loop vectorizatio recurrence in middle
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 1; i < LEN_1D; i++) {
+            a[i] += b[i] * c[i];
+            e[i] = e[i - 1] * e[i - 1];
+            a[i] -= b[i] * c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c
new file mode 100644
index 00000000000..84ae8480476
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2233 (void)
+{
+//    loop interchange
+//    interchanging with one of two inner loops
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int i = 1; i < LEN_2D; i++) {
+            for (int j = 1; j < LEN_2D; j++) {
+                aa[j][i] = aa[j-1][i] + cc[j][i];
+            }
+            for (int j = 1; j < LEN_2D; j++) {
+                bb[i][j] = bb[i-1][j] + cc[i][j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c
new file mode 100644
index 00000000000..4c3ade37a1d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2244 (void)
+{
+//    node splitting
+//    cycle with ture and anti dependency
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+            a[i+1] = b[i] + e[i];
+            a[i] = b[i] + c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c
new file mode 100644
index 00000000000..90de76781a4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2251 (void)
+{
+//    scalar and array expansion
+//    scalar expansion
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        real_t s = (real_t)0.0;
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = s*e[i];
+            s = b[i]+c[i];
+            b[i] = a[i]+d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c
new file mode 100644
index 00000000000..31ae6a96d14
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2275 (void)
+{
+//    loop distribution is needed to be able to interchange
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                aa[j][i] = aa[j][i] + bb[j][i] * cc[j][i];
+            }
+            a[i] = b[i] + c[i] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c
new file mode 100644
index 00000000000..9e8aaf540ff
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s231 (void)
+{
+//    loop interchange
+//    loop with data dependency
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; ++i) {
+            for (int j = 1; j < LEN_2D; j++) {
+                aa[j][i] = aa[j - 1][i] + bb[j][i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c
new file mode 100644
index 00000000000..8afb833eb81
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s232 (void)
+{
+//    loop interchange
+//    interchanging of triangular loops
+
+
+    for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) {
+        for (int j = 1; j < LEN_2D; j++) {
+            for (int i = 1; i <= j; i++) {
+                aa[j][i] = aa[j][i-1]*aa[j][i-1]+bb[j][i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c
new file mode 100644
index 00000000000..ce4f3af14fb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s233 (void)
+{
+//    loop interchange
+//    interchanging with one of two inner loops
+
+
+    for (int nl = 0; nl < 100*(iterations/LEN_2D); nl++) {
+        for (int i = 1; i < LEN_2D; i++) {
+            for (int j = 1; j < LEN_2D; j++) {
+                aa[j][i] = aa[j-1][i] + cc[j][i];
+            }
+            for (int j = 1; j < LEN_2D; j++) {
+                bb[j][i] = bb[j][i-1] + cc[j][i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c
new file mode 100644
index 00000000000..32167370462
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s235 (void)
+{
+//    loop interchanging
+//    imperfectly nested loops
+
+
+    for (int nl = 0; nl < 200*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            a[i] += b[i] * c[i];
+            for (int j = 1; j < LEN_2D; j++) {
+                aa[j][i] = aa[j-1][i] + bb[j][i] * a[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c
new file mode 100644
index 00000000000..76b99267c5d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s241 (void)
+{
+//    node splitting
+//    preloading necessary to allow vectorization
+
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+            a[i] = b[i] * c[i  ] * d[i];
+            b[i] = a[i] * a[i+1] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c
new file mode 100644
index 00000000000..3653ac1ed21
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+struct arg{real_t a;real_t b;};
+
+void s242 (struct arg *x)
+{
+//    node splitting
+
+    real_t s1 = x->a;
+    real_t s2 = x->b;
+
+
+    for (int nl = 0; nl < iterations/5; nl++) {
+        for (int i = 1; i < LEN_1D; ++i) {
+            a[i] = a[i - 1] + s1 + s2 + b[i] + c[i] + d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c
new file mode 100644
index 00000000000..a4afefc5ffe
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s243 (void)
+{
+//    node splitting
+//    false dependence cycle breaking
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+            a[i] = b[i] + c[i  ] * d[i];
+            b[i] = a[i] + d[i  ] * e[i];
+            a[i] = b[i] + a[i+1] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c
new file mode 100644
index 00000000000..b4a59001c9d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s244 (void)
+{
+//    node splitting
+//    false dependence cycle breaking
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; ++i) {
+            a[i] = b[i] + c[i] * d[i];
+            b[i] = c[i] + b[i];
+            a[i+1] = b[i] + a[i+1] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c
new file mode 100644
index 00000000000..ed8db917e00
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s251 (void)
+{
+//    scalar and array expansion
+//    scalar expansion
+
+
+    real_t s;
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            s = b[i] + c[i] * d[i];
+            a[i] = s * s;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c
new file mode 100644
index 00000000000..9f0df999701
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s252 (void)
+{
+//    scalar and array expansion
+//    loop with ambiguous scalar temporary
+
+
+    real_t t, s;
+    for (int nl = 0; nl < iterations; nl++) {
+        t = (real_t) 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            s = b[i] * c[i];
+            a[i] = s + t;
+            t = s;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c
new file mode 100644
index 00000000000..31416f05571
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s253 (void)
+{
+//    scalar and array expansion
+//    scalar expansio assigned under if
+
+
+    real_t s;
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > b[i]) {
+                s = a[i] - b[i] * d[i];
+                c[i] += s;
+                a[i] = s;
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c
new file mode 100644
index 00000000000..d38063e7f12
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s254 (void)
+{
+//    scalar and array expansion
+//    carry around variable
+
+
+    real_t x;
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        x = b[LEN_1D-1];
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = (b[i] + x) * (real_t).5;
+            x = b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c
new file mode 100644
index 00000000000..0762eb202a2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s255 (void)
+{
+//    scalar and array expansion
+//    carry around variables, 2 levels
+
+
+    real_t x, y;
+    for (int nl = 0; nl < iterations; nl++) {
+        x = b[LEN_1D-1];
+        y = b[LEN_1D-2];
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = (b[i] + x + y) * (real_t).333;
+            y = x;
+            x = b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c
new file mode 100644
index 00000000000..95436e79bd4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s256 (void)
+{
+//    scalar and array expansion
+//    array expansion
+
+
+    for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 1; j < LEN_2D; j++) {
+                a[j] = (real_t)1.0 - a[j - 1];
+                aa[j][i] = a[j] + bb[j][i]*d[j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c
new file mode 100644
index 00000000000..c794b7681e7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s257 (void)
+{
+//    scalar and array expansion
+//    array expansion
+
+
+    for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) {
+        for (int i = 1; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                a[i] = aa[j][i] - a[i-1];
+                aa[j][i] = a[i] + bb[j][i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c
new file mode 100644
index 00000000000..5d6983b3811
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s258 (void)
+{
+//    scalar and array expansion
+//    wrap-around scalar under an if
+
+
+    real_t s;
+    for (int nl = 0; nl < iterations; nl++) {
+        s = 0.;
+        for (int i = 0; i < LEN_2D; ++i) {
+            if (a[i] > 0.) {
+                s = d[i] * d[i];
+            }
+            b[i] = s * c[i] + d[i];
+            e[i] = (s + (real_t)1.) * aa[0][i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c
new file mode 100644
index 00000000000..0ad6328c70a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s261 (void)
+{
+//    scalar and array expansion
+//    wrap-around scalar under an if
+
+
+    real_t t;
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 1; i < LEN_1D; ++i) {
+            t = a[i] + b[i];
+            a[i] = t + c[i-1];
+            t = c[i] * d[i];
+            c[i] = t;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c
new file mode 100644
index 00000000000..fc685cc79b1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s271 (void)
+{
+//    control flow
+//    loop with singularity handling
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (b[i] > (real_t)0.) {
+                a[i] += b[i] * c[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c
new file mode 100644
index 00000000000..664427cccd9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c
@@ -0,0 +1,35 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2710 (int x)
+{
+//    control flow
+//    scalar and vector ifs
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > b[i]) {
+                a[i] += b[i] * d[i];
+                if (LEN_1D > 10) {
+                    c[i] += d[i] * d[i];
+                } else {
+                    c[i] = d[i] * e[i] + (real_t)1.;
+                }
+            } else {
+                b[i] = a[i] + e[i] * e[i];
+                if (x > (real_t)0.) {
+                    c[i] = a[i] + d[i] * d[i];
+                } else {
+                    c[i] += e[i] * e[i];
+                }
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c
new file mode 100644
index 00000000000..a16a6e4dae9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2711 (void)
+{
+//    control flow
+//    semantic if removal
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (b[i] != (real_t)0.0) {
+                a[i] += b[i] * c[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c
new file mode 100644
index 00000000000..138b1e9ca5b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s2712 (void)
+{
+//    control flow
+//    if to elemental min
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > b[i]) {
+                a[i] += b[i] * c[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c
new file mode 100644
index 00000000000..19d3e8066da
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s272 (int t)
+{
+//    control flow
+//    loop with independent conditional
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (e[i] >= t) {
+                a[i] += c[i] * d[i];
+                b[i] += c[i] * c[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c
new file mode 100644
index 00000000000..7757620810f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s273 (void)
+{
+//    control flow
+//    simple loop with dependent conditional
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += d[i] * e[i];
+            if (a[i] < (real_t)0.)
+                b[i] += d[i] * e[i];
+            c[i] += a[i] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c
new file mode 100644
index 00000000000..989349b916b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s274 (void)
+{
+//    control flow
+//    complex loop with dependent conditional
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = c[i] + e[i] * d[i];
+            if (a[i] > (real_t)0.) {
+                b[i] = a[i] + b[i];
+            } else {
+                a[i] = d[i] * e[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c
new file mode 100644
index 00000000000..8c247fe4e34
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s275 (void)
+{
+//    control flow
+//    if around inner loop, interchanging needed
+
+
+    for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            if (aa[0][i] > (real_t)0.) {
+                for (int j = 1; j < LEN_2D; j++) {
+                    aa[j][i] = aa[j-1][i] + bb[j][i] * cc[j][i];
+                }
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c
new file mode 100644
index 00000000000..ffa9d356115
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s276 (void)
+{
+//    control flow
+//    if test using loop index
+
+
+    int mid = (LEN_1D/2);
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (i+1 < mid) {
+                a[i] += b[i] * c[i];
+            } else {
+                a[i] += b[i] * d[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c
new file mode 100644
index 00000000000..02756c9f97c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c
@@ -0,0 +1,32 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s277 (void)
+{
+//    control flow
+//    test for dependences arising from guard variable computation.
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++) {
+                if (a[i] >= (real_t)0.) {
+                    goto L20;
+                }
+                if (b[i] >= (real_t)0.) {
+                    goto L30;
+                }
+                a[i] += c[i] * d[i];
+L30:
+                b[i+1] = c[i] + d[i] * e[i];
+L20:
+;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c
new file mode 100644
index 00000000000..9527e3a8cbc
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c
@@ -0,0 +1,30 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s278 (void)
+{
+//    control flow
+//    if/goto to block if-then-else
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > (real_t)0.) {
+                goto L20;
+            }
+            b[i] = -b[i] + d[i] * e[i];
+            goto L30;
+L20:
+            c[i] = -c[i] + d[i] * e[i];
+L30:
+            a[i] = b[i] + c[i] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c
new file mode 100644
index 00000000000..fb25252e51f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c
@@ -0,0 +1,34 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s279 (void)
+{
+//    control flow
+//    vector if/gotos
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > (real_t)0.) {
+                goto L20;
+            }
+            b[i] = -b[i] + d[i] * d[i];
+            if (b[i] <= a[i]) {
+                goto L30;
+            }
+            c[i] += d[i] * e[i];
+            goto L30;
+L20:
+            c[i] = -c[i] + e[i] * e[i];
+L30:
+            a[i] = b[i] + c[i] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c
new file mode 100644
index 00000000000..72f7b539512
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s281 (void)
+{
+//    crossing thresholds
+//    index set splitting
+//    reverse data access
+
+
+    real_t x;
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            x = a[LEN_1D-i-1] + b[i] * c[i];
+            a[i] = x-(real_t)1.0;
+            b[i] = x;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c
new file mode 100644
index 00000000000..7429ca6c0ed
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s291 (void)
+{
+//    loop peeling
+//    wrap around variable, 1 level
+
+
+    int im1;
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        im1 = LEN_1D-1;
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = (b[i] + b[im1]) * (real_t).5;
+            im1 = i;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c
new file mode 100644
index 00000000000..8f8547477f7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s292 (void)
+{
+//    loop peeling
+//    wrap around variable, 2 levels
+//    similar to S291
+
+
+    int im1, im2;
+    for (int nl = 0; nl < iterations; nl++) {
+        im1 = LEN_1D-1;
+        im2 = LEN_1D-2;
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = (b[i] + b[im1] + b[im2]) * (real_t).333;
+            im2 = im1;
+            im1 = i;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c
new file mode 100644
index 00000000000..0f735ddb331
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s293 (void)
+{
+//    loop peeling
+//    a(i)=a(0) with actual dependence cycle, loop is vectorizable
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = a[0];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c
new file mode 100644
index 00000000000..deebb79a511
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s311 (void)
+{
+//    reductions
+//    sum reduction
+
+
+    real_t sum;
+    for (int nl = 0; nl < iterations*10; nl++) {
+        sum = (real_t)0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            sum += a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, sum);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c
new file mode 100644
index 00000000000..f4792983a01
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c
@@ -0,0 +1,35 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s3110 (void)
+{
+//    reductions
+//    if to max with index reductio 2 dimensions
+//    similar to S315
+
+
+    int xindex, yindex;
+    real_t max, chksum;
+    for (int nl = 0; nl < 100*(iterations/(LEN_2D)); nl++) {
+        max = aa[(0)][0];
+        xindex = 0;
+        yindex = 0;
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                if (aa[i][j] > max) {
+                    max = aa[i][j];
+                    xindex = i;
+                    yindex = j;
+                }
+            }
+        }
+        chksum = max + (real_t) xindex + (real_t) yindex;
+        dummy(a, b, c, d, e, aa, bb, cc, chksum);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c
new file mode 100644
index 00000000000..6bb681865c2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s3111 (void)
+{
+//    reductions
+//    conditional sum reduction
+
+
+    real_t sum;
+    for (int nl = 0; nl < iterations/2; nl++) {
+        sum = 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > (real_t)0.) {
+                sum += a[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, sum);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c
new file mode 100644
index 00000000000..a4b39772b60
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c
@@ -0,0 +1,38 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+real_t test(real_t* A){
+  real_t s = (real_t)0.0;
+  for (int i = 0; i < 4; i++)
+    s += A[i];
+  return s;
+}
+
+void s31111 (void)
+{
+//    reductions
+//    sum reduction
+
+
+    real_t sum;
+    for (int nl = 0; nl < 2000*iterations; nl++) {
+        sum = (real_t)0.;
+        sum += test(a);
+        sum += test(&a[4]);
+        sum += test(&a[8]);
+        sum += test(&a[12]);
+        sum += test(&a[16]);
+        sum += test(&a[20]);
+        sum += test(&a[24]);
+        sum += test(&a[28]);
+        dummy(a, b, c, d, e, aa, bb, cc, sum);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c
new file mode 100644
index 00000000000..06dd189781d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s3112 (void)
+{
+//    reductions
+//    sum reduction saving running sums
+
+
+    real_t sum;
+    for (int nl = 0; nl < iterations; nl++) {
+        sum = (real_t)0.0;
+        for (int i = 0; i < LEN_1D; i++) {
+            sum += a[i];
+            b[i] = sum;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, sum);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c
new file mode 100644
index 00000000000..7c7ba129d64
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s3113 (void)
+{
+//    reductions
+//    maximum of absolute value
+
+
+    real_t max;
+    for (int nl = 0; nl < iterations*4; nl++) {
+        max = ABS(a[0]);
+        for (int i = 0; i < LEN_1D; i++) {
+            if ((ABS(a[i])) > max) {
+                max = ABS(a[i]);
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, max);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c
new file mode 100644
index 00000000000..a031d285a85
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s312 (void)
+{
+//    reductions
+//    product reduction
+
+
+    real_t prod;
+    for (int nl = 0; nl < 10*iterations; nl++) {
+        prod = (real_t)1.;
+        for (int i = 0; i < LEN_1D; i++) {
+            prod *= a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, prod);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c
new file mode 100644
index 00000000000..72c2bbfd18f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s313 (void)
+{
+//    reductions
+//    dot product
+
+
+    real_t dot;
+    for (int nl = 0; nl < iterations*5; nl++) {
+        dot = (real_t)0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            dot += a[i] * b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, dot);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c
new file mode 100644
index 00000000000..591cc312565
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s314 (void)
+{
+//    reductions
+//    if to max reduction
+
+
+    real_t x;
+    for (int nl = 0; nl < iterations*5; nl++) {
+        x = a[0];
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > x) {
+                x = a[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, x);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c
new file mode 100644
index 00000000000..e23cef08be3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c
@@ -0,0 +1,34 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s315 (void)
+{
+//    reductions
+//    if to max with index reductio 1 dimension
+
+
+    for (int i = 0; i < LEN_1D; i++)
+        a[i] = (i * 7) % LEN_1D;
+
+    real_t x, chksum;
+    int index;
+    for (int nl = 0; nl < iterations; nl++) {
+        x = a[0];
+        index = 0;
+        for (int i = 0; i < LEN_1D; ++i) {
+            if (a[i] > x) {
+                x = a[i];
+                index = i;
+            }
+        }
+        chksum = x + (real_t) index;
+        dummy(a, b, c, d, e, aa, bb, cc, chksum);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c
new file mode 100644
index 00000000000..72a307a719b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s316 (void)
+{
+//    reductions
+//    if to min reduction
+
+
+    real_t x;
+    for (int nl = 0; nl < iterations*5; nl++) {
+        x = a[0];
+        for (int i = 1; i < LEN_1D; ++i) {
+            if (a[i] < x) {
+                x = a[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, x);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c
new file mode 100644
index 00000000000..61b575aff26
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s317 (void)
+{
+//    reductions
+//    product reductio vectorize with
+//    1. scalar expansion of factor, and product reduction
+//    2. closed form solution: q = factor**n
+
+
+    real_t q;
+    for (int nl = 0; nl < 5*iterations; nl++) {
+        q = (real_t)1.;
+        for (int i = 0; i < LEN_1D/2; i++) {
+            q *= (real_t).99;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, q);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c
new file mode 100644
index 00000000000..57327970a24
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c
@@ -0,0 +1,34 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s318 (int inc)
+{
+//    reductions
+//    isamax, max absolute value, increments not equal to 1
+
+    int k, index;
+    real_t max, chksum;
+    for (int nl = 0; nl < iterations/2; nl++) {
+        k = 0;
+        index = 0;
+        max = ABS(a[0]);
+        k += inc;
+        for (int i = 1; i < LEN_1D; i++) {
+            if (ABS(a[k]) <= max) {
+                goto L5;
+            }
+            index = i;
+            max = ABS(a[k]);
+L5:
+            k += inc;
+        }
+        chksum = max + (real_t) index;
+        dummy(a, b, c, d, e, aa, bb, cc, chksum);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c
new file mode 100644
index 00000000000..4dbd5a88f15
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s319 (void)
+{
+//    reductions
+//    coupled reductions
+
+
+    real_t sum;
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        sum = 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = c[i] + d[i];
+            sum += a[i];
+            b[i] = c[i] + e[i];
+            sum += b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, sum);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c
new file mode 100644
index 00000000000..a17ac96e334
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s321 (void)
+{
+//    recurrences
+//    first order linear recurrence
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 1; i < LEN_1D; i++) {
+            a[i] += a[i-1] * b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c
new file mode 100644
index 00000000000..a82e6b1a9f0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s322 (void)
+{
+//    recurrences
+//    second order linear recurrence
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 2; i < LEN_1D; i++) {
+            a[i] = a[i] + a[i - 1] * b[i] + a[i - 2] * c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c
new file mode 100644
index 00000000000..84ef82e877e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s323 (void)
+{
+//    recurrences
+//    coupled recurrence
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 1; i < LEN_1D; i++) {
+            a[i] = b[i-1] + c[i] * d[i];
+            b[i] = a[i] + c[i] * e[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c
new file mode 100644
index 00000000000..ba5de42d0da
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s3251 (void)
+{
+//    scalar and array expansion
+//    scalar expansion
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D-1; i++){
+            a[i+1] = b[i]+c[i];
+            b[i]   = c[i]*e[i];
+            d[i]   = a[i]*e[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c
new file mode 100644
index 00000000000..be0757713e1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c
@@ -0,0 +1,29 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s331 (void)
+{
+//    search loops
+//    if to last-1
+
+
+    int j;
+    real_t chksum;
+    for (int nl = 0; nl < iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] < (real_t)0.) {
+                j = i;
+            }
+        }
+        chksum = (real_t) j;
+        dummy(a, b, c, d, e, aa, bb, cc, chksum);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c
new file mode 100644
index 00000000000..1bfcd5fed7b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c
@@ -0,0 +1,32 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s332 (int t)
+{
+//    search loops
+//    first value greater than threshold
+
+    int index;
+    real_t value;
+    real_t chksum;
+    for (int nl = 0; nl < iterations; nl++) {
+        index = -2;
+        value = -1.;
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > t) {
+                index = i;
+                value = a[i];
+                goto L20;
+            }
+        }
+L20:
+        chksum = value + (real_t) index;
+        dummy(a, b, c, d, e, aa, bb, cc, chksum);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c
new file mode 100644
index 00000000000..d64bfebf6a1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s341 (void)
+{
+//    packing
+//    pack positive values
+//    not vectorizable, value of j in unknown at each iteration
+
+
+    int j;
+    for (int nl = 0; nl < iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < LEN_1D; i++) {
+            if (b[i] > (real_t)0.) {
+                j++;
+                a[j] = b[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c
new file mode 100644
index 00000000000..883177d37c6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s342 (void)
+{
+//    packing
+//    unpacking
+//    not vectorizable, value of j in unknown at each iteration
+
+
+    int j = 0;
+    for (int nl = 0; nl < iterations; nl++) {
+        j = -1;
+        for (int i = 0; i < LEN_1D; i++) {
+            if (a[i] > (real_t)0.) {
+                j++;
+                a[i] = b[j];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c
new file mode 100644
index 00000000000..6300856ea3a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c
@@ -0,0 +1,30 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s343 (void)
+{
+//    packing
+//    pack 2-d array into one dimension
+//    not vectorizable, value of k in unknown at each iteration
+
+
+    int k;
+    for (int nl = 0; nl < 10*(iterations/LEN_2D); nl++) {
+        k = -1;
+        for (int i = 0; i < LEN_2D; i++) {
+            for (int j = 0; j < LEN_2D; j++) {
+                if (bb[j][i] > (real_t)0.) {
+                    k++;
+                    flat_2d_array[k] = aa[j][i];
+                }
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c
new file mode 100644
index 00000000000..bfe7cee9989
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s351 (void)
+{
+//    loop rerolling
+//    unrolled saxpy
+
+
+    real_t alpha = c[0];
+    for (int nl = 0; nl < 8*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i += 5) {
+            a[i] += alpha * b[i];
+            a[i + 1] += alpha * b[i + 1];
+            a[i + 2] += alpha * b[i + 2];
+            a[i + 3] += alpha * b[i + 3];
+            a[i + 4] += alpha * b[i + 4];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c
new file mode 100644
index 00000000000..28e5d5000c3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s352 (void)
+{
+//    loop rerolling
+//    unrolled dot product
+
+
+    real_t dot;
+    for (int nl = 0; nl < 8*iterations; nl++) {
+        dot = (real_t)0.;
+        for (int i = 0; i < LEN_1D; i += 5) {
+            dot = dot + a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2]
+                * b[i + 2] + a[i + 3] * b[i + 3] + a[i + 4] * b[i + 4];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, dot);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c
new file mode 100644
index 00000000000..1adb9bf5bab
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s353 (int * __restrict__ ip)
+{
+//    loop rerolling
+//    unrolled sparse saxpy
+//    gather is required
+
+    real_t alpha = c[0];
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i += 5) {
+            a[i] += alpha * b[ip[i]];
+            a[i + 1] += alpha * b[ip[i + 1]];
+            a[i + 2] += alpha * b[ip[i + 2]];
+            a[i + 3] += alpha * b[ip[i + 3]];
+            a[i + 4] += alpha * b[ip[i + 4]];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c
new file mode 100644
index 00000000000..10197f751d7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c
@@ -0,0 +1,30 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+struct arg{int * __restrict__ a;real_t b;};
+
+void s4112 (struct arg *x)
+{
+//    indirect addressing
+//    sparse saxpy
+//    gather is required
+
+    int * __restrict__ ip = x->a;
+    real_t s = x->b;
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += b[ip[i]] * s;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c
new file mode 100644
index 00000000000..49bbe22b474
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s4113 (int * __restrict__ ip)
+{
+//    indirect addressing
+//    indirect addressing on rhs and lhs
+//    gather and scatter is required
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[ip[i]] = b[ip[i]] + c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c
new file mode 100644
index 00000000000..d036ffcdce3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c
@@ -0,0 +1,33 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+struct arg{int * __restrict__ a;int b;};
+
+void s4114 (struct arg *x)
+{
+//    indirect addressing
+//    mix indirect addressing with variable lower and upper bounds
+//    gather is required
+
+    int * __restrict__ ip = x->a;
+    int n1 = x->b;
+
+
+    int k;
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = n1-1; i < LEN_1D; i++) {
+            k = ip[i];
+            a[i] = b[i] + c[LEN_1D-k+1-2] * d[i];
+            k += 5;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c
new file mode 100644
index 00000000000..871fd1b8dd3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s4115 (int * __restrict__ ip)
+{
+//    indirect addressing
+//    sparse dot product
+//    gather is required
+
+    real_t sum;
+    for (int nl = 0; nl < iterations; nl++) {
+        sum = 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            sum += a[i] * b[ip[i]];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c
new file mode 100644
index 00000000000..8c6ac7edc35
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c
@@ -0,0 +1,33 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+struct arg{int * __restrict__ a;int b;int c;};
+
+void s4116 (struct arg *x)
+{
+//    indirect addressing
+//    more complicated sparse sdot
+//    gather is required
+
+    int * __restrict__ ip = x->a;
+    int j = x->b;
+    int inc = x->c;
+
+
+    real_t sum;
+    int off;
+    for (int nl = 0; nl < 100*iterations; nl++) {
+        sum = 0.;
+        for (int i = 0; i < LEN_2D-1; i++) {
+            off = inc + i;
+            sum += a[off] * aa[j-1][ip[i]];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c
new file mode 100644
index 00000000000..6b220f31d6c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s4117 (void)
+{
+//    indirect addressing
+//    seq function
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = b[i] + c[i/2] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c
new file mode 100644
index 00000000000..999f78adf2f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+real_t f(real_t a, real_t b){
+    return a*b;
+}
+
+void s4121 (void)
+{
+//    statement functions
+//    elementwise multiplication
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += f(b[i],c[i]);
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c
new file mode 100644
index 00000000000..eaa502699d4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s421 (void)
+{
+//    storage classes and equivalencing
+//    equivalence- no overlap
+
+
+    xx = flat_2d_array;
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        yy = xx;
+        for (int i = 0; i < LEN_1D - 1; i++) {
+            xx[i] = yy[i+1] + a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c
new file mode 100644
index 00000000000..63b9104ff8b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c
@@ -0,0 +1,26 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s422 (void)
+{
+//    storage classes and equivalencing
+//    common and equivalence statement
+//    anti-dependence, threshold of 4
+
+
+    xx = flat_2d_array + 4;
+
+    for (int nl = 0; nl < 8*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            xx[i] = flat_2d_array[i + 8] + a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c
new file mode 100644
index 00000000000..75eb4359382
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s423 (void)
+{
+//    storage classes and equivalencing
+//    common and equivalenced variables - with anti-dependence
+
+    // do this again here
+    int vl = 64;
+    xx = flat_2d_array + vl;
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D - 1; i++) {
+            flat_2d_array[i+1] = xx[i] + a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c
new file mode 100644
index 00000000000..145a2af9ede
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s424 (void)
+{
+//    storage classes and equivalencing
+//    common and equivalenced variables - overlap
+//    vectorizeable in strips of 64 or less
+
+    // do this again here
+    int vl = 63;
+    xx = flat_2d_array + vl;
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D - 1; i++) {
+            xx[i+1] = flat_2d_array[i] + a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 1.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c
new file mode 100644
index 00000000000..4f2597aff8f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c
@@ -0,0 +1,27 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s431 (void)
+{
+//    parameters
+//    parameter statement
+
+    int k1=1;
+    int k2=2;
+    int k=2*k1-k2;
+
+
+    for (int nl = 0; nl < iterations*10; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = a[i+k] + b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c
new file mode 100644
index 00000000000..7f7ab226fcd
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c
@@ -0,0 +1,28 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s441 (void)
+{
+//    non-logical if's
+//    arithmetic if
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (d[i] < (real_t)0.) {
+                a[i] += b[i] * c[i];
+            } else if (d[i] == (real_t)0.) {
+                a[i] += b[i] * b[i];
+            } else {
+                a[i] += c[i] * c[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c
new file mode 100644
index 00000000000..1c459e05151
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c
@@ -0,0 +1,40 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s442 (void)
+{
+//    non-logical if's
+//    computed goto
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            switch (indx[i]) {
+                case 1:  goto L15;
+                case 2:  goto L20;
+                case 3:  goto L30;
+                case 4:  goto L40;
+            }
+L15:
+            a[i] += b[i] * b[i];
+            goto L50;
+L20:
+            a[i] += c[i] * c[i];
+            goto L50;
+L30:
+            a[i] += d[i] * d[i];
+            goto L50;
+L40:
+            a[i] += e[i] * e[i];
+L50:
+            ;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c
new file mode 100644
index 00000000000..a8623f9119a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c
@@ -0,0 +1,33 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s443 (void)
+{
+//    non-logical if's
+//    arithmetic if
+
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (d[i] <= (real_t)0.) {
+                goto L20;
+            } else {
+                goto L30;
+            }
+L20:
+            a[i] += b[i] * c[i];
+            goto L50;
+L30:
+            a[i] += b[i] * b[i];
+L50:
+            ;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c
new file mode 100644
index 00000000000..3b13b2c7e13
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s451 (void)
+{
+//    intrinsic functions
+//    intrinsics
+
+
+    for (int nl = 0; nl < iterations/5; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = sinf(b[i]) + cosf(c[i]);
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c
new file mode 100644
index 00000000000..7e0dc2190d6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s452 (void)
+{
+//    intrinsic functions
+//    seq function
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = b[i] + c[i] * (real_t) (i+1);
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c
new file mode 100644
index 00000000000..c0115ce3753
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s453 (void)
+{
+//    induction varibale recognition
+
+    real_t s;
+
+
+    for (int nl = 0; nl < iterations*2; nl++) {
+        s = 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            s += (real_t)2.;
+            a[i] = s * b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c
new file mode 100644
index 00000000000..5de316738f9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c
@@ -0,0 +1,33 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+int s471s(void)
+{
+// --  dummy subroutine call made in s471
+    return 0;
+}
+
+void s471 (void)
+{
+//    call statements
+
+    int m = LEN_1D;
+
+
+    for (int nl = 0; nl < iterations/2; nl++) {
+        for (int i = 0; i < m; i++) {
+            x[i] = b[i] + d[i] * d[i];
+            s471s();
+            b[i] = c[i] + d[i] * e[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c
new file mode 100644
index 00000000000..6ad8272aeb2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s481 (void)
+{
+//    non-local goto's
+//    stop statement
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (d[i] < (real_t)0.) {
+                exit (0);
+            }
+            a[i] += b[i] * c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c
new file mode 100644
index 00000000000..bba5f744453
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s482 (void)
+{
+//    non-local goto's
+//    other loop exit with code before exit
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += b[i] * c[i];
+            if (c[i] > b[i]) break;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c
new file mode 100644
index 00000000000..546ba056955
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void s491 (int * __restrict__ ip)
+{
+//    vector semantics
+//    indirect addressing on lhs, store in sequence
+//    scatter is required
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[ip[i]] = b[i] + c[i] * d[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c
new file mode 100644
index 00000000000..6cce1d173cf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void va (void)
+{
+//    control loops
+//    vector assignment
+
+
+    for (int nl = 0; nl < iterations*10; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c
new file mode 100644
index 00000000000..9d994cad60a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vag (int * __restrict__ ip)
+{
+//    control loops
+//    vector assignment, gather
+//    gather is required
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = b[ip[i]];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c
new file mode 100644
index 00000000000..104e587ec14
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c
@@ -0,0 +1,22 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vas (int * __restrict__ ip)
+{
+//    control loops
+//    vector assignment, scatter
+//    scatter is required
+
+    for (int nl = 0; nl < 2*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[ip[i]] = b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c
new file mode 100644
index 00000000000..8455c94ce37
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c
@@ -0,0 +1,38 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vbor (void)
+{
+//    control loops
+//    basic operations rates, isolate arithmetic from memory traffic
+//    all combinations of three, 59 flops for 6 loads and 1 store.
+
+
+    real_t a1, b1, c1, d1, e1, f1;
+    for (int nl = 0; nl < iterations*10; nl++) {
+        for (int i = 0; i < LEN_2D; i++) {
+            a1 = a[i];
+            b1 = b[i];
+            c1 = c[i];
+            d1 = d[i];
+            e1 = e[i];
+            f1 = aa[0][i];
+            a1 = a1 * b1 * c1 + a1 * b1 * d1 + a1 * b1 * e1 + a1 * b1 * f1 +
+                a1 * c1 * d1 + a1 * c1 * e1 + a1 * c1 * f1 + a1 * d1 * e1
+                + a1 * d1 * f1 + a1 * e1 * f1;
+            b1 = b1 * c1 * d1 + b1 * c1 * e1 + b1 * c1 * f1 + b1 * d1 * e1 +
+                b1 * d1 * f1 + b1 * e1 * f1;
+            c1 = c1 * d1 * e1 + c1 * d1 * f1 + c1 * e1 * f1;
+            d1 = d1 * e1 * f1;
+            x[i] = a1 * b1 * c1 * d1;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c
new file mode 100644
index 00000000000..56adc5180c2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vdotr (void)
+{
+//    control loops
+//    vector dot product reduction
+
+
+    real_t dot;
+    for (int nl = 0; nl < iterations*10; nl++) {
+        dot = 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            dot += a[i] * b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, dot);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c
new file mode 100644
index 00000000000..c3830822cae
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c
@@ -0,0 +1,24 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vif (void)
+{
+//    control loops
+//    vector if
+
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            if (b[i] > (real_t)0.) {
+                a[i] = b[i];
+            }
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c
new file mode 100644
index 00000000000..68d3025f536
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vpv (void)
+{
+//    control loops
+//    vector plus vector
+
+
+    for (int nl = 0; nl < iterations*10; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c
new file mode 100644
index 00000000000..652e0424d01
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vpvpv (void)
+{
+//    control loops
+//    vector plus vector plus vector
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += b[i] + c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c
new file mode 100644
index 00000000000..9531fd1df3c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vpvts (real_t s)
+{
+//    control loops
+//    vector plus vector times scalar
+
+    for (int nl = 0; nl < iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += b[i] * s;
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c
new file mode 100644
index 00000000000..3ab6b836a8e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vpvtv (void)
+{
+//    control loops
+//    vector plus vector times vector
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] += b[i] * c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c
new file mode 100644
index 00000000000..73c644abcd6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c
@@ -0,0 +1,25 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vsumr (void)
+{
+//    control loops
+//    vector sum reduction
+
+
+    real_t sum;
+    for (int nl = 0; nl < iterations*10; nl++) {
+        sum = 0.;
+        for (int i = 0; i < LEN_1D; i++) {
+            sum += a[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, sum);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c
new file mode 100644
index 00000000000..24bdfa55522
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vtv (void)
+{
+//    control loops
+//    vector times vector
+
+
+    for (int nl = 0; nl < iterations*10; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] *= b[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c
new file mode 100644
index 00000000000..39dfbb98d1a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c
@@ -0,0 +1,23 @@
+/*  This file is distributed under the University of Illinois Open Source
+    License. See license.txt for details.  */
+
+/* { dg-do compile } */
+/* { dg-additional-options "--param vect-epilogues-nomask=0" } */
+/* { dg-require-effective-target vect_float } */
+
+#include "tsvc.h"
+
+void vtvtv (void)
+{
+//    control loops
+//    vector times vector times vector
+
+
+    for (int nl = 0; nl < 4*iterations; nl++) {
+        for (int i = 0; i < LEN_1D; i++) {
+            a[i] = a[i] * b[i] * c[i];
+        }
+        dummy(a, b, c, d, e, aa, bb, cc, 0.);
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
\ No newline at end of file
