diff mbox series

Add TSVC tests.

Message ID 13efb730-e52a-158e-7a60-54c204434b77@suse.cz
State New
Headers show
Series Add TSVC tests. | expand

Commit Message

Martin Liška Oct. 18, 2021, 8:59 a.m. UTC
Hello.

The ambition of the patch is addition of TSVC_2 loop tests to GCC test-suite:
https://github.com/UoB-HPC/TSVC_2

Right now, I add only compile tests where I scan for number of loops vectorized.

Patch can bootstrap on x86_64-linux-gnu and survives regression tests.

Thoughts?
Thanks,
Martin

gcc/testsuite/ChangeLog:

	* gcc.dg/vect/license.txt: New test.
	* gcc.dg/vect/tsvc.h: New test.
	* gcc.dg/vect/vect-tsvc-s000.c: New test.
	* gcc.dg/vect/vect-tsvc-s111.c: New test.
	* gcc.dg/vect/vect-tsvc-s1111.c: New test.
	* gcc.dg/vect/vect-tsvc-s1112.c: New test.
	* gcc.dg/vect/vect-tsvc-s1113.c: New test.
	* gcc.dg/vect/vect-tsvc-s1115.c: New test.
	* gcc.dg/vect/vect-tsvc-s1119.c: New test.
	* gcc.dg/vect/vect-tsvc-s112.c: New test.
	* gcc.dg/vect/vect-tsvc-s113.c: New test.
	* gcc.dg/vect/vect-tsvc-s114.c: New test.
	* gcc.dg/vect/vect-tsvc-s115.c: New test.
	* gcc.dg/vect/vect-tsvc-s116.c: New test.
	* gcc.dg/vect/vect-tsvc-s1161.c: New test.
	* gcc.dg/vect/vect-tsvc-s118.c: New test.
	* gcc.dg/vect/vect-tsvc-s119.c: New test.
	* gcc.dg/vect/vect-tsvc-s121.c: New test.
	* gcc.dg/vect/vect-tsvc-s1213.c: New test.
	* gcc.dg/vect/vect-tsvc-s122.c: New test.
	* gcc.dg/vect/vect-tsvc-s1221.c: New test.
	* gcc.dg/vect/vect-tsvc-s123.c: New test.
	* gcc.dg/vect/vect-tsvc-s1232.c: New test.
	* gcc.dg/vect/vect-tsvc-s124.c: New test.
	* gcc.dg/vect/vect-tsvc-s1244.c: New test.
	* gcc.dg/vect/vect-tsvc-s125.c: New test.
	* gcc.dg/vect/vect-tsvc-s1251.c: New test.
	* gcc.dg/vect/vect-tsvc-s126.c: New test.
	* gcc.dg/vect/vect-tsvc-s127.c: New test.
	* gcc.dg/vect/vect-tsvc-s1279.c: New test.
	* gcc.dg/vect/vect-tsvc-s128.c: New test.
	* gcc.dg/vect/vect-tsvc-s1281.c: New test.
	* gcc.dg/vect/vect-tsvc-s131.c: New test.
	* gcc.dg/vect/vect-tsvc-s13110.c: New test.
	* gcc.dg/vect/vect-tsvc-s132.c: New test.
	* gcc.dg/vect/vect-tsvc-s1351.c: New test.
	* gcc.dg/vect/vect-tsvc-s141.c: New test.
	* gcc.dg/vect/vect-tsvc-s1421.c: New test.
	* gcc.dg/vect/vect-tsvc-s151.c: New test.
	* gcc.dg/vect/vect-tsvc-s152.c: New test.
	* gcc.dg/vect/vect-tsvc-s161.c: New test.
	* gcc.dg/vect/vect-tsvc-s162.c: New test.
	* gcc.dg/vect/vect-tsvc-s171.c: New test.
	* gcc.dg/vect/vect-tsvc-s172.c: New test.
	* gcc.dg/vect/vect-tsvc-s173.c: New test.
	* gcc.dg/vect/vect-tsvc-s174.c: New test.
	* gcc.dg/vect/vect-tsvc-s175.c: New test.
	* gcc.dg/vect/vect-tsvc-s176.c: New test.
	* gcc.dg/vect/vect-tsvc-s2101.c: New test.
	* gcc.dg/vect/vect-tsvc-s2102.c: New test.
	* gcc.dg/vect/vect-tsvc-s211.c: New test.
	* gcc.dg/vect/vect-tsvc-s2111.c: New test.
	* gcc.dg/vect/vect-tsvc-s212.c: New test.
	* gcc.dg/vect/vect-tsvc-s221.c: New test.
	* gcc.dg/vect/vect-tsvc-s222.c: New test.
	* gcc.dg/vect/vect-tsvc-s2233.c: New test.
	* gcc.dg/vect/vect-tsvc-s2244.c: New test.
	* gcc.dg/vect/vect-tsvc-s2251.c: New test.
	* gcc.dg/vect/vect-tsvc-s2275.c: New test.
	* gcc.dg/vect/vect-tsvc-s231.c: New test.
	* gcc.dg/vect/vect-tsvc-s232.c: New test.
	* gcc.dg/vect/vect-tsvc-s233.c: New test.
	* gcc.dg/vect/vect-tsvc-s235.c: New test.
	* gcc.dg/vect/vect-tsvc-s241.c: New test.
	* gcc.dg/vect/vect-tsvc-s242.c: New test.
	* gcc.dg/vect/vect-tsvc-s243.c: New test.
	* gcc.dg/vect/vect-tsvc-s244.c: New test.
	* gcc.dg/vect/vect-tsvc-s251.c: New test.
	* gcc.dg/vect/vect-tsvc-s252.c: New test.
	* gcc.dg/vect/vect-tsvc-s253.c: New test.
	* gcc.dg/vect/vect-tsvc-s254.c: New test.
	* gcc.dg/vect/vect-tsvc-s255.c: New test.
	* gcc.dg/vect/vect-tsvc-s256.c: New test.
	* gcc.dg/vect/vect-tsvc-s257.c: New test.
	* gcc.dg/vect/vect-tsvc-s258.c: New test.
	* gcc.dg/vect/vect-tsvc-s261.c: New test.
	* gcc.dg/vect/vect-tsvc-s271.c: New test.
	* gcc.dg/vect/vect-tsvc-s2710.c: New test.
	* gcc.dg/vect/vect-tsvc-s2711.c: New test.
	* gcc.dg/vect/vect-tsvc-s2712.c: New test.
	* gcc.dg/vect/vect-tsvc-s272.c: New test.
	* gcc.dg/vect/vect-tsvc-s273.c: New test.
	* gcc.dg/vect/vect-tsvc-s274.c: New test.
	* gcc.dg/vect/vect-tsvc-s275.c: New test.
	* gcc.dg/vect/vect-tsvc-s276.c: New test.
	* gcc.dg/vect/vect-tsvc-s277.c: New test.
	* gcc.dg/vect/vect-tsvc-s278.c: New test.
	* gcc.dg/vect/vect-tsvc-s279.c: New test.
	* gcc.dg/vect/vect-tsvc-s281.c: New test.
	* gcc.dg/vect/vect-tsvc-s291.c: New test.
	* gcc.dg/vect/vect-tsvc-s292.c: New test.
	* gcc.dg/vect/vect-tsvc-s293.c: New test.
	* gcc.dg/vect/vect-tsvc-s311.c: New test.
	* gcc.dg/vect/vect-tsvc-s3110.c: New test.
	* gcc.dg/vect/vect-tsvc-s3111.c: New test.
	* gcc.dg/vect/vect-tsvc-s31111.c: New test.
	* gcc.dg/vect/vect-tsvc-s3112.c: New test.
	* gcc.dg/vect/vect-tsvc-s3113.c: New test.
	* gcc.dg/vect/vect-tsvc-s312.c: New test.
	* gcc.dg/vect/vect-tsvc-s313.c: New test.
	* gcc.dg/vect/vect-tsvc-s314.c: New test.
	* gcc.dg/vect/vect-tsvc-s315.c: New test.
	* gcc.dg/vect/vect-tsvc-s316.c: New test.
	* gcc.dg/vect/vect-tsvc-s317.c: New test.
	* gcc.dg/vect/vect-tsvc-s318.c: New test.
	* gcc.dg/vect/vect-tsvc-s319.c: New test.
	* gcc.dg/vect/vect-tsvc-s321.c: New test.
	* gcc.dg/vect/vect-tsvc-s322.c: New test.
	* gcc.dg/vect/vect-tsvc-s323.c: New test.
	* gcc.dg/vect/vect-tsvc-s3251.c: New test.
	* gcc.dg/vect/vect-tsvc-s331.c: New test.
	* gcc.dg/vect/vect-tsvc-s332.c: New test.
	* gcc.dg/vect/vect-tsvc-s341.c: New test.
	* gcc.dg/vect/vect-tsvc-s342.c: New test.
	* gcc.dg/vect/vect-tsvc-s343.c: New test.
	* gcc.dg/vect/vect-tsvc-s351.c: New test.
	* gcc.dg/vect/vect-tsvc-s352.c: New test.
	* gcc.dg/vect/vect-tsvc-s353.c: New test.
	* gcc.dg/vect/vect-tsvc-s4112.c: New test.
	* gcc.dg/vect/vect-tsvc-s4113.c: New test.
	* gcc.dg/vect/vect-tsvc-s4114.c: New test.
	* gcc.dg/vect/vect-tsvc-s4115.c: New test.
	* gcc.dg/vect/vect-tsvc-s4116.c: New test.
	* gcc.dg/vect/vect-tsvc-s4117.c: New test.
	* gcc.dg/vect/vect-tsvc-s4121.c: New test.
	* gcc.dg/vect/vect-tsvc-s421.c: New test.
	* gcc.dg/vect/vect-tsvc-s422.c: New test.
	* gcc.dg/vect/vect-tsvc-s423.c: New test.
	* gcc.dg/vect/vect-tsvc-s424.c: New test.
	* gcc.dg/vect/vect-tsvc-s431.c: New test.
	* gcc.dg/vect/vect-tsvc-s441.c: New test.
	* gcc.dg/vect/vect-tsvc-s442.c: New test.
	* gcc.dg/vect/vect-tsvc-s443.c: New test.
	* gcc.dg/vect/vect-tsvc-s451.c: New test.
	* gcc.dg/vect/vect-tsvc-s452.c: New test.
	* gcc.dg/vect/vect-tsvc-s453.c: New test.
	* gcc.dg/vect/vect-tsvc-s471.c: New test.
	* gcc.dg/vect/vect-tsvc-s481.c: New test.
	* gcc.dg/vect/vect-tsvc-s482.c: New test.
	* gcc.dg/vect/vect-tsvc-s491.c: New test.
	* gcc.dg/vect/vect-tsvc-va.c: New test.
	* gcc.dg/vect/vect-tsvc-vag.c: New test.
	* gcc.dg/vect/vect-tsvc-vas.c: New test.
	* gcc.dg/vect/vect-tsvc-vbor.c: New test.
	* gcc.dg/vect/vect-tsvc-vdotr.c: New test.
	* gcc.dg/vect/vect-tsvc-vif.c: New test.
	* gcc.dg/vect/vect-tsvc-vpv.c: New test.
	* gcc.dg/vect/vect-tsvc-vpvpv.c: New test.
	* gcc.dg/vect/vect-tsvc-vpvts.c: New test.
	* gcc.dg/vect/vect-tsvc-vpvtv.c: New test.
	* gcc.dg/vect/vect-tsvc-vsumr.c: New test.
	* gcc.dg/vect/vect-tsvc-vtv.c: New test.
	* gcc.dg/vect/vect-tsvc-vtvtv.c: New test.
---
  gcc/testsuite/gcc.dg/vect/license.txt        | 58 ++++++++++++++++++++
  gcc/testsuite/gcc.dg/vect/tsvc.h             | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c  | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c  | 31 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c   | 32 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c  | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c   | 30 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c   | 30 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c  | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c  | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c   | 29 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c  | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c | 34 ++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c  | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c   | 29 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c   | 30 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c   | 31 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c   | 21 +++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c  | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c  | 35 ++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c   | 32 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c   | 30 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c   | 34 ++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c   | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c  | 35 ++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c  | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c | 38 +++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c  | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c   | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c   | 34 ++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c   | 34 ++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c   | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c   | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c   | 29 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c   | 32 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c   | 30 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c  | 30 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c  | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c  | 33 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c  | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c  | 33 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c  | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c   | 26 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c   | 27 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c   | 28 ++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c   | 40 ++++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c   | 33 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c   | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c   | 33 +++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c   | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c   | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c   | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c     | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c    | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c    | 22 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c   | 38 +++++++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c    | 24 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c    | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c  | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c  | 25 +++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c    | 23 ++++++++
  gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c  | 23 ++++++++
  153 files changed, 4044 insertions(+)
  create mode 100644 gcc/testsuite/gcc.dg/vect/license.txt
  create mode 100644 gcc/testsuite/gcc.dg/vect/tsvc.h
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c
  create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c

Comments

Richard Biener Oct. 18, 2021, 10:08 a.m. UTC | #1
On Mon, Oct 18, 2021 at 10:59 AM Martin Liška <mliska@suse.cz> wrote:
>
> Hello.
>
> The ambition of the patch is addition of TSVC_2 loop tests to GCC test-suite:
> https://github.com/UoB-HPC/TSVC_2
>
> Right now, I add only compile tests where I scan for number of loops vectorized.
>
> Patch can bootstrap on x86_64-linux-gnu and survives regression tests.
>
> Thoughts?

Can you please use a subdirectory for the sources, a "toplevel"
license.txt doesn't make much sense.  You can simply amend
vect.exp to process tsvc/*.c as well as sources so no need for an
extra .exp file.

Is the license recognized as
compatible to the GPL as far as source distribution is concerned?

Did you test the testcases on any non-x86 target?  (power/aarch64/arm)

Richard.

> Thanks,
> Martin
>
> gcc/testsuite/ChangeLog:
>
>         * gcc.dg/vect/license.txt: New test.
>         * gcc.dg/vect/tsvc.h: New test.
>         * gcc.dg/vect/vect-tsvc-s000.c: New test.
>         * gcc.dg/vect/vect-tsvc-s111.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1111.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1112.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1113.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1115.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1119.c: New test.
>         * gcc.dg/vect/vect-tsvc-s112.c: New test.
>         * gcc.dg/vect/vect-tsvc-s113.c: New test.
>         * gcc.dg/vect/vect-tsvc-s114.c: New test.
>         * gcc.dg/vect/vect-tsvc-s115.c: New test.
>         * gcc.dg/vect/vect-tsvc-s116.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1161.c: New test.
>         * gcc.dg/vect/vect-tsvc-s118.c: New test.
>         * gcc.dg/vect/vect-tsvc-s119.c: New test.
>         * gcc.dg/vect/vect-tsvc-s121.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1213.c: New test.
>         * gcc.dg/vect/vect-tsvc-s122.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1221.c: New test.
>         * gcc.dg/vect/vect-tsvc-s123.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1232.c: New test.
>         * gcc.dg/vect/vect-tsvc-s124.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1244.c: New test.
>         * gcc.dg/vect/vect-tsvc-s125.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1251.c: New test.
>         * gcc.dg/vect/vect-tsvc-s126.c: New test.
>         * gcc.dg/vect/vect-tsvc-s127.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1279.c: New test.
>         * gcc.dg/vect/vect-tsvc-s128.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1281.c: New test.
>         * gcc.dg/vect/vect-tsvc-s131.c: New test.
>         * gcc.dg/vect/vect-tsvc-s13110.c: New test.
>         * gcc.dg/vect/vect-tsvc-s132.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1351.c: New test.
>         * gcc.dg/vect/vect-tsvc-s141.c: New test.
>         * gcc.dg/vect/vect-tsvc-s1421.c: New test.
>         * gcc.dg/vect/vect-tsvc-s151.c: New test.
>         * gcc.dg/vect/vect-tsvc-s152.c: New test.
>         * gcc.dg/vect/vect-tsvc-s161.c: New test.
>         * gcc.dg/vect/vect-tsvc-s162.c: New test.
>         * gcc.dg/vect/vect-tsvc-s171.c: New test.
>         * gcc.dg/vect/vect-tsvc-s172.c: New test.
>         * gcc.dg/vect/vect-tsvc-s173.c: New test.
>         * gcc.dg/vect/vect-tsvc-s174.c: New test.
>         * gcc.dg/vect/vect-tsvc-s175.c: New test.
>         * gcc.dg/vect/vect-tsvc-s176.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2101.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2102.c: New test.
>         * gcc.dg/vect/vect-tsvc-s211.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2111.c: New test.
>         * gcc.dg/vect/vect-tsvc-s212.c: New test.
>         * gcc.dg/vect/vect-tsvc-s221.c: New test.
>         * gcc.dg/vect/vect-tsvc-s222.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2233.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2244.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2251.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2275.c: New test.
>         * gcc.dg/vect/vect-tsvc-s231.c: New test.
>         * gcc.dg/vect/vect-tsvc-s232.c: New test.
>         * gcc.dg/vect/vect-tsvc-s233.c: New test.
>         * gcc.dg/vect/vect-tsvc-s235.c: New test.
>         * gcc.dg/vect/vect-tsvc-s241.c: New test.
>         * gcc.dg/vect/vect-tsvc-s242.c: New test.
>         * gcc.dg/vect/vect-tsvc-s243.c: New test.
>         * gcc.dg/vect/vect-tsvc-s244.c: New test.
>         * gcc.dg/vect/vect-tsvc-s251.c: New test.
>         * gcc.dg/vect/vect-tsvc-s252.c: New test.
>         * gcc.dg/vect/vect-tsvc-s253.c: New test.
>         * gcc.dg/vect/vect-tsvc-s254.c: New test.
>         * gcc.dg/vect/vect-tsvc-s255.c: New test.
>         * gcc.dg/vect/vect-tsvc-s256.c: New test.
>         * gcc.dg/vect/vect-tsvc-s257.c: New test.
>         * gcc.dg/vect/vect-tsvc-s258.c: New test.
>         * gcc.dg/vect/vect-tsvc-s261.c: New test.
>         * gcc.dg/vect/vect-tsvc-s271.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2710.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2711.c: New test.
>         * gcc.dg/vect/vect-tsvc-s2712.c: New test.
>         * gcc.dg/vect/vect-tsvc-s272.c: New test.
>         * gcc.dg/vect/vect-tsvc-s273.c: New test.
>         * gcc.dg/vect/vect-tsvc-s274.c: New test.
>         * gcc.dg/vect/vect-tsvc-s275.c: New test.
>         * gcc.dg/vect/vect-tsvc-s276.c: New test.
>         * gcc.dg/vect/vect-tsvc-s277.c: New test.
>         * gcc.dg/vect/vect-tsvc-s278.c: New test.
>         * gcc.dg/vect/vect-tsvc-s279.c: New test.
>         * gcc.dg/vect/vect-tsvc-s281.c: New test.
>         * gcc.dg/vect/vect-tsvc-s291.c: New test.
>         * gcc.dg/vect/vect-tsvc-s292.c: New test.
>         * gcc.dg/vect/vect-tsvc-s293.c: New test.
>         * gcc.dg/vect/vect-tsvc-s311.c: New test.
>         * gcc.dg/vect/vect-tsvc-s3110.c: New test.
>         * gcc.dg/vect/vect-tsvc-s3111.c: New test.
>         * gcc.dg/vect/vect-tsvc-s31111.c: New test.
>         * gcc.dg/vect/vect-tsvc-s3112.c: New test.
>         * gcc.dg/vect/vect-tsvc-s3113.c: New test.
>         * gcc.dg/vect/vect-tsvc-s312.c: New test.
>         * gcc.dg/vect/vect-tsvc-s313.c: New test.
>         * gcc.dg/vect/vect-tsvc-s314.c: New test.
>         * gcc.dg/vect/vect-tsvc-s315.c: New test.
>         * gcc.dg/vect/vect-tsvc-s316.c: New test.
>         * gcc.dg/vect/vect-tsvc-s317.c: New test.
>         * gcc.dg/vect/vect-tsvc-s318.c: New test.
>         * gcc.dg/vect/vect-tsvc-s319.c: New test.
>         * gcc.dg/vect/vect-tsvc-s321.c: New test.
>         * gcc.dg/vect/vect-tsvc-s322.c: New test.
>         * gcc.dg/vect/vect-tsvc-s323.c: New test.
>         * gcc.dg/vect/vect-tsvc-s3251.c: New test.
>         * gcc.dg/vect/vect-tsvc-s331.c: New test.
>         * gcc.dg/vect/vect-tsvc-s332.c: New test.
>         * gcc.dg/vect/vect-tsvc-s341.c: New test.
>         * gcc.dg/vect/vect-tsvc-s342.c: New test.
>         * gcc.dg/vect/vect-tsvc-s343.c: New test.
>         * gcc.dg/vect/vect-tsvc-s351.c: New test.
>         * gcc.dg/vect/vect-tsvc-s352.c: New test.
>         * gcc.dg/vect/vect-tsvc-s353.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4112.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4113.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4114.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4115.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4116.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4117.c: New test.
>         * gcc.dg/vect/vect-tsvc-s4121.c: New test.
>         * gcc.dg/vect/vect-tsvc-s421.c: New test.
>         * gcc.dg/vect/vect-tsvc-s422.c: New test.
>         * gcc.dg/vect/vect-tsvc-s423.c: New test.
>         * gcc.dg/vect/vect-tsvc-s424.c: New test.
>         * gcc.dg/vect/vect-tsvc-s431.c: New test.
>         * gcc.dg/vect/vect-tsvc-s441.c: New test.
>         * gcc.dg/vect/vect-tsvc-s442.c: New test.
>         * gcc.dg/vect/vect-tsvc-s443.c: New test.
>         * gcc.dg/vect/vect-tsvc-s451.c: New test.
>         * gcc.dg/vect/vect-tsvc-s452.c: New test.
>         * gcc.dg/vect/vect-tsvc-s453.c: New test.
>         * gcc.dg/vect/vect-tsvc-s471.c: New test.
>         * gcc.dg/vect/vect-tsvc-s481.c: New test.
>         * gcc.dg/vect/vect-tsvc-s482.c: New test.
>         * gcc.dg/vect/vect-tsvc-s491.c: New test.
>         * gcc.dg/vect/vect-tsvc-va.c: New test.
>         * gcc.dg/vect/vect-tsvc-vag.c: New test.
>         * gcc.dg/vect/vect-tsvc-vas.c: New test.
>         * gcc.dg/vect/vect-tsvc-vbor.c: New test.
>         * gcc.dg/vect/vect-tsvc-vdotr.c: New test.
>         * gcc.dg/vect/vect-tsvc-vif.c: New test.
>         * gcc.dg/vect/vect-tsvc-vpv.c: New test.
>         * gcc.dg/vect/vect-tsvc-vpvpv.c: New test.
>         * gcc.dg/vect/vect-tsvc-vpvts.c: New test.
>         * gcc.dg/vect/vect-tsvc-vpvtv.c: New test.
>         * gcc.dg/vect/vect-tsvc-vsumr.c: New test.
>         * gcc.dg/vect/vect-tsvc-vtv.c: New test.
>         * gcc.dg/vect/vect-tsvc-vtvtv.c: New test.
> ---
>   gcc/testsuite/gcc.dg/vect/license.txt        | 58 ++++++++++++++++++++
>   gcc/testsuite/gcc.dg/vect/tsvc.h             | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c  | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c  | 31 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c   | 32 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c  | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c   | 30 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c   | 30 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c  | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c  | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c   | 29 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c  | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c | 34 ++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c  | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c   | 29 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c   | 30 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c   | 31 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c   | 21 +++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c  | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c  | 35 ++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c   | 32 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c   | 30 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c   | 34 ++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c   | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c  | 35 ++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c  | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c | 38 +++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c  | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c   | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c   | 34 ++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c   | 34 ++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c   | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c   | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c   | 29 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c   | 32 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c   | 30 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c  | 30 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c  | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c  | 33 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c  | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c  | 33 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c  | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c   | 26 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c   | 27 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c   | 28 ++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c   | 40 ++++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c   | 33 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c   | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c   | 33 +++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c   | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c   | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c   | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c     | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c    | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c    | 22 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c   | 38 +++++++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c    | 24 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c    | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c  | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c  | 25 +++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c    | 23 ++++++++
>   gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c  | 23 ++++++++
>   153 files changed, 4044 insertions(+)
>   create mode 100644 gcc/testsuite/gcc.dg/vect/license.txt
>   create mode 100644 gcc/testsuite/gcc.dg/vect/tsvc.h
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s000.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s111.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1111.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1112.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1113.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1115.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1119.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s112.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s113.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s114.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s115.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s116.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1161.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s118.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s119.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s121.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1213.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s122.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1221.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s123.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1232.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s124.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1244.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s125.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1251.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s126.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s127.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1279.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s128.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1281.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s131.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s13110.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s132.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1351.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s141.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s1421.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s151.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s152.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s161.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s162.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s171.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s172.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s173.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s174.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s175.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s176.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2101.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2102.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s211.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2111.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s212.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s221.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s222.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2233.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2244.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2251.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2275.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s231.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s232.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s233.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s235.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s241.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s242.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s243.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s244.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s251.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s252.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s253.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s254.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s255.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s256.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s257.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s258.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s261.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s271.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2710.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2711.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s2712.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s272.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s273.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s274.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s275.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s276.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s277.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s278.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s279.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s281.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s291.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s292.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s293.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s311.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3110.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3111.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s31111.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3112.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3113.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s312.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s313.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s314.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s315.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s316.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s317.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s318.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s319.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s321.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s322.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s323.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s3251.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s331.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s332.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s341.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s342.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s343.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s351.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s352.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s353.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4112.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4113.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4114.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4115.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4116.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4117.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s4121.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s421.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s422.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s423.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s424.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s431.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s441.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s442.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s443.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s451.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s452.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s453.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s471.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s481.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s482.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-s491.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-va.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vag.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vas.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vbor.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vdotr.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vif.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpv.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvpv.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvts.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vpvtv.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vsumr.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vtv.c
>   create mode 100644 gcc/testsuite/gcc.dg/vect/vect-tsvc-vtvtv.c
>
> diff --git a/gcc/testsuite/gcc.dg/vect/license.txt b/gcc/testsuite/gcc.dg/vect/license.txt
> new file mode 100644
> index 00000000000..782154d4adf
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/vect/license.txt
> @@ -0,0 +1,58 @@
> +Copyright (c) 2011 University of Illinois at Urbana-Champaign.  All rights reserved.
> +
> +
> +
> +Developed by: Polaris Research Group
> +
> +              University of Illinois at Urbana-Champaign
> +
> +              http://polaris.cs.uiuc.edu
> +
> +
> +
> +Permission is hereby granted, free of charge, to any person obtaining a copy
> +
> +of this software and associated documentation files (the "Software"), to
> +
> +deal with the Software without restriction, including without limitation the
> +
> +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
> +
> +sell copies of the Software, and to permit persons to whom the Software is
> +
> +furnished to do so, subject to the following conditions:
> +
> +  1. Redistributions of source code must retain the above copyright notice,
> +
> +     this list of conditions and the following disclaimers.
> +
> +  2. Redistributions in binary form must reproduce the above copyright
> +
> +     notice, this list of conditions and the following disclaimers in the
> +
> +     documentation and/or other materials provided with the distribution.
> +
> +  3. Neither the names of Polaris Research Group, University of Illinois at
> +
> +     Urbana-Champaign, nor the names of its contributors may be used to endorse
> +
> +     or promote products derived from this Software without specific prior
> +
> +     written permission.
> +
> +
> +
> +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> +
> +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> +
> +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
> +
> +CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> +
> +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> +
> +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> +
> +WITH THE SOFTWARE.
> +
> diff --git a/gcc/testsuite/gcc.dg/vect/tsvc.h b/gcc/testsuite/gcc.dg/vect/tsvc.h
> new file mode 100644
> index 00000000000..cfc00cba0c5
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/vect/tsvc.h
> @@ -0,0 +1,25 @@
> +#define iterations 100000
> +#define LEN_1D 32000
> +#define LEN_2D 256
> +#define ARRAY_ALIGNMENT 64
> +
> +#include <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
> --
> 2.33.0
>
Martin Liška Oct. 19, 2021, 6:49 a.m. UTC | #2
On 10/18/21 12:08, Richard Biener wrote:
> Can you please use a subdirectory for the sources, a "toplevel"
> license.txt doesn't make much sense.  You can simply amend
> vect.exp to process tsvc/*.c as well as sources so no need for an
> extra .exp file.

Sure, it's a good idea and I've done that.

> 
> Is the license recognized as
> compatible to the GPL as far as source distribution is concerned?

Yes: https://www.gnu.org/licenses/license-list.html#NCSA

> 
> Did you test the testcases on any non-x86 target?  (power/aarch64/arm)

Yes, I run the tests also on ppc64le-linux-gnu and aarch64-linux-gnu.

Thoughts?
Thanks,
Martin

> 
> Richard.
Martin Liška Oct. 25, 2021, 1:40 p.m. UTC | #3
PING^1

On 10/19/21 08:49, Martin Liška wrote:
> On 10/18/21 12:08, Richard Biener wrote:
>> Can you please use a subdirectory for the sources, a "toplevel"
>> license.txt doesn't make much sense.  You can simply amend
>> vect.exp to process tsvc/*.c as well as sources so no need for an
>> extra .exp file.
> 
> Sure, it's a good idea and I've done that.
> 
>>
>> Is the license recognized as
>> compatible to the GPL as far as source distribution is concerned?
> 
> Yes: https://www.gnu.org/licenses/license-list.html#NCSA
> 
>>
>> Did you test the testcases on any non-x86 target?  (power/aarch64/arm)
> 
> Yes, I run the tests also on ppc64le-linux-gnu and aarch64-linux-gnu.
> 
> Thoughts?
> Thanks,
> Martin
> 
>>
>> Richard.
Richard Biener Oct. 26, 2021, 8:13 a.m. UTC | #4
On Tue, Oct 19, 2021 at 8:49 AM Martin Liška <mliska@suse.cz> wrote:
>
> On 10/18/21 12:08, Richard Biener wrote:
> > Can you please use a subdirectory for the sources, a "toplevel"
> > license.txt doesn't make much sense.  You can simply amend
> > vect.exp to process tsvc/*.c as well as sources so no need for an
> > extra .exp file.
>
> Sure, it's a good idea and I've done that.
>
> >
> > Is the license recognized as
> > compatible to the GPL as far as source distribution is concerned?
>
> Yes: https://www.gnu.org/licenses/license-list.html#NCSA
>
> >
> > Did you test the testcases on any non-x86 target?  (power/aarch64/arm)
>
> Yes, I run the tests also on ppc64le-linux-gnu and aarch64-linux-gnu.
>
> Thoughts?

The overall setup looks fine to me.  There are quite some testcases
where there are no dg-final directives, some indicate in comments
that we do not expect vectorization - for those do we want to
add scan-tree-dump-not "loop vectorized" or so to make that clear?
For others do we want to add XFAILs so we'll notice when we improve
on TSVC?  It looks like for example s124 is looking for IVOPTs rather
than vectorization?  There are testcases exercising float compares
(s124 is an example), vectorizing those likely requires a subset
of fast-math flags to allow if-conversion and masking, plus masking
is not available on all targets.  Is the intent to adjust testcase options
accordingly?

That said, I wonder whether it makes sense to initially only add
the parts having dg-final directives (that PASS or XFAIL), just
adding testcases for testing compile looks superfluous.

All of the testcases are dg-do compile, but vectorizer testcases
ideally would come with runtime verification.  I assume the
original TSVC provides this and as you include tscv.h in all
tests I suppose including a runtime harness would be possible, no?

Thanks,
Richard.

> Thanks,
> Martin
>
> >
> > Richard.
Martin Liška Oct. 26, 2021, 3:27 p.m. UTC | #5
On 10/26/21 10:13, Richard Biener wrote:
> On Tue, Oct 19, 2021 at 8:49 AM Martin Liška <mliska@suse.cz> wrote:
>>
>> On 10/18/21 12:08, Richard Biener wrote:
>>> Can you please use a subdirectory for the sources, a "toplevel"
>>> license.txt doesn't make much sense.  You can simply amend
>>> vect.exp to process tsvc/*.c as well as sources so no need for an
>>> extra .exp file.
>>
>> Sure, it's a good idea and I've done that.
>>
>>>
>>> Is the license recognized as
>>> compatible to the GPL as far as source distribution is concerned?
>>
>> Yes: https://www.gnu.org/licenses/license-list.html#NCSA
>>
>>>
>>> Did you test the testcases on any non-x86 target?  (power/aarch64/arm)
>>
>> Yes, I run the tests also on ppc64le-linux-gnu and aarch64-linux-gnu.
>>
>> Thoughts?
> 

Hey.

> The overall setup looks fine to me.  There are quite some testcases
> where there are no dg-final directives, some indicate in comments
> that we do not expect vectorization - for those do we want to
> add scan-tree-dump-not "loop vectorized" or so to make that clear?

In the updated version of the patch I added:
/* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */

> For others do we want to add XFAILs so we'll notice when we improve
> on TSVC?

What type of XFAILs do you mean?

> It looks like for example s124 is looking for IVOPTs rather
> than vectorization?  There are testcases exercising float compares
> (s124 is an example), vectorizing those likely requires a subset
> of fast-math flags to allow if-conversion and masking, plus masking
> is not available on all targets.  Is the intent to adjust testcase options
> accordingly?

No, this is out of my scope, it has already taken me some time...

> 
> That said, I wonder whether it makes sense to initially only add
> the parts having dg-final directives (that PASS or XFAIL), just
> adding testcases for testing compile looks superfluous.
> 
> All of the testcases are dg-do compile, but vectorizer testcases
> ideally would come with runtime verification.  I assume the
> original TSVC provides this and as you include tscv.h in all
> tests I suppose including a runtime harness would be possible, no?

All right, I'm adding also run-time checking. It took me some time making
array initialization for all tests independent. Plus I reduced number of
iterations to 1/10 of the origin. That makes tests quite fast.

What do you think about it now?
Martin

> 
> Thanks,
> Richard.
> 
>> Thanks,
>> Martin
>>
>>>
>>> Richard.
Richard Biener Oct. 29, 2021, 9:36 a.m. UTC | #6
On Tue, Oct 26, 2021 at 5:27 PM Martin Liška <mliska@suse.cz> wrote:
>
> On 10/26/21 10:13, Richard Biener wrote:
> > On Tue, Oct 19, 2021 at 8:49 AM Martin Liška <mliska@suse.cz> wrote:
> >>
> >> On 10/18/21 12:08, Richard Biener wrote:
> >>> Can you please use a subdirectory for the sources, a "toplevel"
> >>> license.txt doesn't make much sense.  You can simply amend
> >>> vect.exp to process tsvc/*.c as well as sources so no need for an
> >>> extra .exp file.
> >>
> >> Sure, it's a good idea and I've done that.
> >>
> >>>
> >>> Is the license recognized as
> >>> compatible to the GPL as far as source distribution is concerned?
> >>
> >> Yes: https://www.gnu.org/licenses/license-list.html#NCSA
> >>
> >>>
> >>> Did you test the testcases on any non-x86 target?  (power/aarch64/arm)
> >>
> >> Yes, I run the tests also on ppc64le-linux-gnu and aarch64-linux-gnu.
> >>
> >> Thoughts?
> >
>
> Hey.
>
> > The overall setup looks fine to me.  There are quite some testcases
> > where there are no dg-final directives, some indicate in comments
> > that we do not expect vectorization - for those do we want to
> > add scan-tree-dump-not "loop vectorized" or so to make that clear?
>
> In the updated version of the patch I added:
> /* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */
>
> > For others do we want to add XFAILs so we'll notice when we improve
> > on TSVC?
>
> What type of XFAILs do you mean?

Like

/* { dg-final { scann-tree-dump "vectorized 1 loops" "vect" { xfail
*-*-* } } } */

when the testcase looks for vectorization but we don't do that (yet).
For s1113 for example you added a scan-tree-dump-not but the comment
suggests we'd expect vectorization.

> > It looks like for example s124 is looking for IVOPTs rather
> > than vectorization?  There are testcases exercising float compares
> > (s124 is an example), vectorizing those likely requires a subset
> > of fast-math flags to allow if-conversion and masking, plus masking
> > is not available on all targets.  Is the intent to adjust testcase options
> > accordingly?
>
> No, this is out of my scope, it has already taken me some time...

OK.

> >
> > That said, I wonder whether it makes sense to initially only add
> > the parts having dg-final directives (that PASS or XFAIL), just
> > adding testcases for testing compile looks superfluous.
> >
> > All of the testcases are dg-do compile, but vectorizer testcases
> > ideally would come with runtime verification.  I assume the
> > original TSVC provides this and as you include tscv.h in all
> > tests I suppose including a runtime harness would be possible, no?
>
> All right, I'm adding also run-time checking. It took me some time making
> array initialization for all tests independent. Plus I reduced number of
> iterations to 1/10 of the origin. That makes tests quite fast.
>
> What do you think about it now?

It looks nice now, but as said above some of the scan-tree-dump-not
should probably be xfailed scan-tree-dump, I was suggesting the
-not for the cases where vectorizing would be semantically wrong.

So I'd say OK with that change.

Thanks,
Richard.

> Martin
>
> >
> > Thanks,
> > Richard.
> >
> >> Thanks,
> >> Martin
> >>
> >>>
> >>> Richard.
Martin Liška Nov. 2, 2021, 8:41 a.m. UTC | #7
On 10/29/21 11:36, Richard Biener wrote:
> On Tue, Oct 26, 2021 at 5:27 PM Martin Liška <mliska@suse.cz> wrote:
>>
>> On 10/26/21 10:13, Richard Biener wrote:
>>> On Tue, Oct 19, 2021 at 8:49 AM Martin Liška <mliska@suse.cz> wrote:
>>>>
>>>> On 10/18/21 12:08, Richard Biener wrote:
>>>>> Can you please use a subdirectory for the sources, a "toplevel"
>>>>> license.txt doesn't make much sense.  You can simply amend
>>>>> vect.exp to process tsvc/*.c as well as sources so no need for an
>>>>> extra .exp file.
>>>>
>>>> Sure, it's a good idea and I've done that.
>>>>
>>>>>
>>>>> Is the license recognized as
>>>>> compatible to the GPL as far as source distribution is concerned?
>>>>
>>>> Yes: https://www.gnu.org/licenses/license-list.html#NCSA
>>>>
>>>>>
>>>>> Did you test the testcases on any non-x86 target?  (power/aarch64/arm)
>>>>
>>>> Yes, I run the tests also on ppc64le-linux-gnu and aarch64-linux-gnu.
>>>>
>>>> Thoughts?
>>>
>>
>> Hey.
>>
>>> The overall setup looks fine to me.  There are quite some testcases
>>> where there are no dg-final directives, some indicate in comments
>>> that we do not expect vectorization - for those do we want to
>>> add scan-tree-dump-not "loop vectorized" or so to make that clear?
>>
>> In the updated version of the patch I added:
>> /* { dg-final { scan-tree-dump-not "vectorized \[1-9\] loops" "vect" } } */
>>
>>> For others do we want to add XFAILs so we'll notice when we improve
>>> on TSVC?
>>
>> What type of XFAILs do you mean?
> 
> Like
> 
> /* { dg-final { scann-tree-dump "vectorized 1 loops" "vect" { xfail
> *-*-* } } } */

All right. The only limitation with that I see is that we can vectorize
more loops in the future and this pattern is still going to xfail.
We won't notice, right?

> 
> when the testcase looks for vectorization but we don't do that (yet).
> For s1113 for example you added a scan-tree-dump-not but the comment
> suggests we'd expect vectorization.

The comment comes from the original source of TSVC. I copied entire functions.

> 
>>> It looks like for example s124 is looking for IVOPTs rather
>>> than vectorization?  There are testcases exercising float compares
>>> (s124 is an example), vectorizing those likely requires a subset
>>> of fast-math flags to allow if-conversion and masking, plus masking
>>> is not available on all targets.  Is the intent to adjust testcase options
>>> accordingly?
>>
>> No, this is out of my scope, it has already taken me some time...
> 
> OK.
> 
>>>
>>> That said, I wonder whether it makes sense to initially only add
>>> the parts having dg-final directives (that PASS or XFAIL), just
>>> adding testcases for testing compile looks superfluous.
>>>
>>> All of the testcases are dg-do compile, but vectorizer testcases
>>> ideally would come with runtime verification.  I assume the
>>> original TSVC provides this and as you include tscv.h in all
>>> tests I suppose including a runtime harness would be possible, no?
>>
>> All right, I'm adding also run-time checking. It took me some time making
>> array initialization for all tests independent. Plus I reduced number of
>> iterations to 1/10 of the origin. That makes tests quite fast.
>>
>> What do you think about it now?
> 
> It looks nice now, but as said above some of the scan-tree-dump-not
> should probably be xfailed scan-tree-dump, I was suggesting the
> -not for the cases where vectorizing would be semantically wrong.

I see.

> 
> So I'd say OK with that change.

Installed that, thanks for review.

Martin

> 
> Thanks,
> Richard.
> 
>> Martin
>>
>>>
>>> Thanks,
>>> Richard.
>>>
>>>> Thanks,
>>>> Martin
>>>>
>>>>>
>>>>> Richard.
diff mbox series

Patch

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