[OPENMP] Allow only loop control variables in distribute simd

directives.

According to the OpenMP standard, only loop control variables can be
used in linear clauses of distribute-based simd directives.

llvm-svn: 319362

14 files changed, 174 insertions, 440 deletions

diff --git a/clang/test/OpenMP/distribute_parallel_for_simd_ast_print.cpp b/clang/test/OpenMP/distribute_parallel_for_simd_ast_print.cpp
index 6ed3f219225..464acbe19c6 100644
--- a/clang/test/OpenMP/distribute_parallel_for_simd_ast_print.cpp
+++ b/clang/test/OpenMP/distribute_parallel_for_simd_ast_print.cpp
@@ -28,17 +28,18 @@ public:
       ++this->a.a;
   }
   S7 &operator=(S7 &s) {
+    int k;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute parallel for simd private(a) private(this->a)
-    for (int k = 0; k < s.a.a; ++k)
+#pragma omp distribute parallel for simd private(a) private(this->a) linear(k)
+    for (k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
 // CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) private(T::a)
-// CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a)
+// CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) linear(k)
 // CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
@@ -135,14 +136,15 @@ int main(int argc, char **argv) {
   // CHECK-NEXT: for (int j = 0; j < 10; ++j)
   // CHECK-NEXT: a++;
 
+  int i;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute parallel for simd aligned(x:8) linear(h:2) safelen(8) simdlen(8)
-  for (int i = 0; i < 100; i++)
+#pragma omp distribute parallel for simd aligned(x:8) linear(i:2) safelen(8) simdlen(8)
+  for (i = 0; i < 100; i++)
     for (int j = 0; j < 200; j++)
       a += h + x[j];
-  // CHECK: #pragma omp distribute parallel for simd aligned(x: 8) linear(h: 2) safelen(8) simdlen(8)
-  // CHECK-NEXT: for (int i = 0; i < 100; i++)
+  // CHECK: #pragma omp distribute parallel for simd aligned(x: 8) linear(i: 2) safelen(8) simdlen(8)
+  // CHECK-NEXT: for (i = 0; i < 100; i++)
   // CHECK-NEXT: for (int j = 0; j < 200; j++)
   // CHECK-NEXT: a += h + x[j];
 
diff --git a/clang/test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp b/clang/test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp
index 632ef066c0f..66fd94b9e0f 100644
--- a/clang/test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp
+++ b/clang/test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp
@@ -18,41 +18,49 @@ void test_linear_colons()
 {
   int B = 0;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(B:bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(B::ib:B:bfoo()) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(B:ib) // expected-error {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(z:B:ib) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'?}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(B:B::bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(X::x : ::z)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(B,::z, X::x)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(::z)
@@ -63,6 +71,7 @@ void test_linear_colons()
 #pragma omp distribute parallel for simd linear(B::bfoo()) // expected-error {{expected variable name}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(B::ib,B:C1+C2)
@@ -148,11 +157,13 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute parallel for simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
@@ -163,6 +174,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear (argc : 5)
@@ -183,6 +195,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute parallel for simd linear (argv[1]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(e, g)
@@ -193,6 +206,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute parallel for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear(i)
@@ -202,28 +216,13 @@ template<class I, class C> int foomain(I argc, C **argv) {
   {
     int v = 0;
     int i;
+    int k;
     #pragma omp target
     #pragma omp teams
-    #pragma omp distribute parallel for simd linear(v:i)
-    for (int k = 0; k < argc; ++k) { i = k; v += i; }
+    #pragma omp distribute parallel for simd linear(k:i)
+    for (k = 0; k < argc; ++k) { i = k; v += i; }
   }
 
-#pragma omp target
-#pragma omp teams
-#pragma omp parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-  int v = 0;
-
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute parallel for simd linear(v:j)
-  for (int k = 0; k < argc; ++k) { ++k; v += j; }
-
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute parallel for simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
   return 0;
 }
 
@@ -262,11 +261,13 @@ int main(int argc, char **argv) {
 #pragma omp distribute parallel for simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
@@ -277,6 +278,7 @@ int main(int argc, char **argv) {
 #pragma omp distribute parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd linear (argc)
@@ -314,24 +316,14 @@ int main(int argc, char **argv) {
     #pragma omp target
     #pragma omp teams
     #pragma omp distribute parallel for simd linear(i)
-      for (int k = 0; k < argc; ++k) ++k;
+      for (i = 0; i < argc; ++i) ++i;
 
     #pragma omp target
     #pragma omp teams
     #pragma omp distribute parallel for simd linear(i : 4)
-      for (int k = 0; k < argc; ++k) { ++k; i += 4; }
+      for (i = 0; i < argc; ++i) { ++i; i += 4; }
   }
 
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute parallel for simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
-
   foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
   return 0;
 }
diff --git a/clang/test/OpenMP/distribute_parallel_for_simd_misc_messages.c b/clang/test/OpenMP/distribute_parallel_for_simd_misc_messages.c
index 01c079e3dac..bb24c23d4f4 100644
--- a/clang/test/OpenMP/distribute_parallel_for_simd_misc_messages.c
+++ b/clang/test/OpenMP/distribute_parallel_for_simd_misc_messages.c
@@ -68,7 +68,7 @@ void test_non_identifiers() {
 #pragma omp target
 #pragma omp teams
 // expected-warning@+1 {{extra tokens at the end of '#pragma omp distribute parallel for simd' are ignored}}
-#pragma omp distribute parallel for simd linear(x);
+#pragma omp distribute parallel for simd firstprivate(x);
   for (i = 0; i < 16; ++i)
     ;
 
@@ -548,89 +548,6 @@ void test_linear() {
 #pragma omp distribute parallel for simd linear(x, y, z)
   for (i = 0; i < 16; ++i)
     ;
-
-  int x, y;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected expression}}
-#pragma omp distribute parallel for simd linear(x :)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
-#pragma omp distribute parallel for simd linear(x :, )
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute parallel for simd linear(x : 1)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute parallel for simd linear(x : 2 * 2)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
-#pragma omp distribute parallel for simd linear(x : 1, y)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
-#pragma omp distribute parallel for simd linear(x : 1, y, z : 1)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as linear}}
-// expected-error@+1 {{linear variable cannot be linear}}
-#pragma omp distribute parallel for simd linear(x) linear(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as private}}
-// expected-error@+1 {{private variable cannot be linear}}
-#pragma omp distribute parallel for simd private(x) linear(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as linear}}
-// expected-error@+1 {{linear variable cannot be private}}
-#pragma omp distribute parallel for simd linear(x) private(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}}
-#pragma omp distribute parallel for simd linear(x, y : 0)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as linear}}
-// expected-error@+1 {{linear variable cannot be lastprivate}}
-#pragma omp distribute parallel for simd linear(x) lastprivate(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as lastprivate}}
-// expected-error@+1 {{lastprivate variable cannot be linear}}
-#pragma omp distribute parallel for simd lastprivate(x) linear(x)
-  for (i = 0; i < 16; ++i)
-    ;
 }
 
 void test_aligned() {
diff --git a/clang/test/OpenMP/distribute_simd_ast_print.cpp b/clang/test/OpenMP/distribute_simd_ast_print.cpp
index 6d2e916292f..6ac4b849a27 100644
--- a/clang/test/OpenMP/distribute_simd_ast_print.cpp
+++ b/clang/test/OpenMP/distribute_simd_ast_print.cpp
@@ -129,14 +129,15 @@ int main(int argc, char **argv) {
 // CHECK-NEXT: for (int j = 0; j < 10; ++j)
 // CHECK-NEXT: a++;
 
+  int i;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute simd aligned(x:8) linear(h:2) safelen(8) simdlen(8)
-  for (int i = 0; i < 100; i++)
+#pragma omp distribute simd aligned(x:8) linear(i:2) safelen(8) simdlen(8)
+  for (i = 0; i < 100; i++)
     for (int j = 0; j < 200; j++)
       a += h + x[j];
-// CHECK: #pragma omp distribute simd aligned(x: 8) linear(h: 2) safelen(8) simdlen(8)
-// CHECK-NEXT: for (int i = 0; i < 100; i++)
+// CHECK: #pragma omp distribute simd aligned(x: 8) linear(i: 2) safelen(8) simdlen(8)
+// CHECK-NEXT: for (i = 0; i < 100; i++)
 // CHECK-NEXT: for (int j = 0; j < 200; j++)
 // CHECK-NEXT: a += h + x[j];
 
diff --git a/clang/test/OpenMP/distribute_simd_linear_messages.cpp b/clang/test/OpenMP/distribute_simd_linear_messages.cpp
index c60e0a24707..e4d71fee825 100644
--- a/clang/test/OpenMP/distribute_simd_linear_messages.cpp
+++ b/clang/test/OpenMP/distribute_simd_linear_messages.cpp
@@ -18,41 +18,49 @@ void test_linear_colons()
 {
   int B = 0;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(B:bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(B::ib:B:bfoo()) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(B:ib) // expected-error {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(z:B:ib) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'?}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(B:B::bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(X::x : ::z)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(B,::z, X::x)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(::z)
@@ -63,6 +71,7 @@ void test_linear_colons()
 #pragma omp distribute simd linear(B::bfoo()) // expected-error {{expected variable name}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+3 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(B::ib,B:C1+C2)
@@ -148,11 +157,13 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
@@ -163,6 +174,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear (argc : 5)
@@ -183,6 +195,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute simd linear (argv[1]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(e, g)
@@ -193,37 +206,12 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp distribute simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear(i)
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int v = 0;
-    int i;
-    #pragma omp target
-    #pragma omp teams
-    #pragma omp distribute simd linear(v:i)
-    for (int k = 0; k < argc; ++k) { i = k; v += i; }
-  }
-
-#pragma omp target
-#pragma omp teams
-#pragma omp parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-  int v = 0;
-
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute simd linear(v:j)
-  for (int k = 0; k < argc; ++k) { ++k; v += j; }
-
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
   return 0;
 }
 
@@ -262,11 +250,13 @@ int main(int argc, char **argv) {
 #pragma omp distribute simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
@@ -277,6 +267,7 @@ int main(int argc, char **argv) {
 #pragma omp distribute simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd linear (argc)
@@ -310,28 +301,18 @@ int main(int argc, char **argv) {
 
   #pragma omp parallel
   {
-    int i;
+    int k;
     #pragma omp target
     #pragma omp teams
-    #pragma omp distribute simd linear(i)
-      for (int k = 0; k < argc; ++k) ++k;
+    #pragma omp distribute simd linear(k)
+      for (k = 0; k < argc; ++k) ++k;
 
     #pragma omp target
     #pragma omp teams
-    #pragma omp distribute simd linear(i : 4)
-      for (int k = 0; k < argc; ++k) { ++k; i += 4; }
+    #pragma omp distribute simd linear(k : 4)
+      for (k = 0; k < argc; k+=4) { }
   }
 
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
-
   foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
   return 0;
 }
diff --git a/clang/test/OpenMP/distribute_simd_misc_messages.c b/clang/test/OpenMP/distribute_simd_misc_messages.c
index 5fc2cb64cc6..f643ed1d5b8 100644
--- a/clang/test/OpenMP/distribute_simd_misc_messages.c
+++ b/clang/test/OpenMP/distribute_simd_misc_messages.c
@@ -561,89 +561,6 @@ void test_linear() {
 #pragma omp distribute simd linear(x, y, z)
   for (i = 0; i < 16; ++i)
     ;
-
-  int x, y;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected expression}}
-#pragma omp distribute simd linear(x :)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
-#pragma omp distribute simd linear(x :, )
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute simd linear(x : 1)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-#pragma omp distribute simd linear(x : 2 * 2)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
-#pragma omp distribute simd linear(x : 1, y)
-  for (i = 0; i < 16; ++i)
-    ;
-#pragma omp target
-#pragma omp teams
-// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}}
-#pragma omp distribute simd linear(x : 1, y, z : 1)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as linear}}
-// expected-error@+1 {{linear variable cannot be linear}}
-#pragma omp distribute simd linear(x) linear(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as private}}
-// expected-error@+1 {{private variable cannot be linear}}
-#pragma omp distribute simd private(x) linear(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as linear}}
-// expected-error@+1 {{linear variable cannot be private}}
-#pragma omp distribute simd linear(x) private(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}}
-#pragma omp distribute simd linear(x, y : 0)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as linear}}
-// expected-error@+1 {{linear variable cannot be lastprivate}}
-#pragma omp distribute simd linear(x) lastprivate(x)
-  for (i = 0; i < 16; ++i)
-    ;
-
-#pragma omp target
-#pragma omp teams
-// expected-note@+2 {{defined as lastprivate}}
-// expected-error@+1 {{lastprivate variable cannot be linear}}
-#pragma omp distribute simd lastprivate(x) linear(x)
-  for (i = 0; i < 16; ++i)
-    ;
 }
 
 void test_aligned() {
@@ -1083,26 +1000,26 @@ void test_loop_messages() {
 }
 
 void linear_modifiers(int argc) {
-  int f;
+  int k;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute simd linear(f)
-  for (int k = 0; k < argc; ++k) ++k;
+#pragma omp distribute simd linear(k)
+  for (k = 0; k < argc; ++k) ++k;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute simd linear(val(f))
-  for (int k = 0; k < argc; ++k) ++k;
+#pragma omp distribute simd linear(val(k))
+  for (k = 0; k < argc; ++k) ++k;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute simd linear(uval(f)) // expected-error {{expected 'val' modifier}}
-  for (int k = 0; k < argc; ++k) ++k;
+#pragma omp distribute simd linear(uval(k)) // expected-error {{expected 'val' modifier}}
+  for (k = 0; k < argc; ++k) ++k;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute simd linear(ref(f)) // expected-error {{expected 'val' modifier}}
-  for (int k = 0; k < argc; ++k) ++k;
+#pragma omp distribute simd linear(ref(k)) // expected-error {{expected 'val' modifier}}
+  for (k = 0; k < argc; ++k) ++k;
 #pragma omp target
 #pragma omp teams
-#pragma omp distribute simd linear(foo(f)) // expected-error {{expected 'val' modifier}}
-  for (int k = 0; k < argc; ++k) ++k;
+#pragma omp distribute simd linear(foo(k)) // expected-error {{expected 'val' modifier}}
+  for (k = 0; k < argc; ++k) ++k;
 }
 
diff --git a/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_ast_print.cpp b/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_ast_print.cpp
index 29a0c6d3633..af588f1b81d 100644
--- a/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_ast_print.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_ast_print.cpp
@@ -28,8 +28,9 @@ public:
       ++this->a.a;
   }
   S7 &operator=(S7 &s) {
-#pragma omp target teams distribute parallel for simd private(a) private(this->a)
-    for (int k = 0; k < s.a.a; ++k)
+    int k;
+#pragma omp target teams distribute parallel for simd private(a) private(this->a) linear(k)
+    for (k = 0; k < s.a.a; ++k)
       ++s.a.a;
 
     foo();
@@ -53,7 +54,7 @@ public:
   }
 };
 // CHECK: #pragma omp target teams distribute parallel for simd private(this->a) private(this->a) private(T::a)
-// CHECK: #pragma omp target teams distribute parallel for simd private(this->a) private(this->a)
+// CHECK: #pragma omp target teams distribute parallel for simd private(this->a) private(this->a) linear(k)
 // CHECK: #pragma omp target teams distribute parallel for simd default(none) private(b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK: #pragma omp target teams distribute parallel for simd simdlen(slen1) safelen(slen2) aligned(arr: alen)
 
@@ -135,10 +136,10 @@ T tmain(T argc) {
 // CHECK: #pragma omp target teams distribute parallel for simd default(none) private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
-#pragma omp target teams distribute parallel for simd simdlen(clen-1) linear(d)
+#pragma omp target teams distribute parallel for simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
-// CHECK: #pragma omp target teams distribute parallel for simd simdlen(clen - 1) linear(d)
+// CHECK: #pragma omp target teams distribute parallel for simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target teams distribute parallel for simd safelen(clen-1) aligned(arr:alen)
@@ -186,10 +187,10 @@ int main (int argc, char **argv) {
 // CHECK: #pragma omp target teams distribute parallel for simd default(none) private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
-#pragma omp target teams distribute parallel for simd simdlen(clen-1) linear(d)
+#pragma omp target teams distribute parallel for simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
-// CHECK: #pragma omp target teams distribute parallel for simd simdlen(clen - 1) linear(d)
+// CHECK: #pragma omp target teams distribute parallel for simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target teams distribute parallel for simd safelen(clen-1) aligned(arr:N+6)
diff --git a/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_linear_messages.cpp b/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_linear_messages.cpp
index 24c432ade9e..257244ede44 100644
--- a/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_linear_messages.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_linear_messages.cpp
@@ -18,33 +18,42 @@ void test_linear_colons()
 {
   int B = 0;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(B:bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(B::ib:B:bfoo()) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(B:ib) // expected-error {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(z:B:ib) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'?}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(B:B::bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(X::x : ::z)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(B,::z, X::x)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(::z)
   for (int i = 0; i < 10; ++i) ;
 
 #pragma omp target teams distribute parallel for simd linear(B::bfoo()) // expected-error {{expected variable name}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
 }
@@ -65,6 +74,7 @@ template<int L, class T, class N> T test_template(T* arr, N num) {
 
 template<int LEN> int test_warn() {
   int ind2 = 0;
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
   #pragma omp target teams distribute parallel for simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
@@ -118,15 +128,18 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp target teams distribute parallel for simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
 #pragma omp target teams distribute parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear (argc : 5)
   for (int k = 0; k < argc; ++k) ++k;
 
@@ -139,33 +152,17 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp target teams distribute parallel for simd linear (argv[1]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(e, g)
   for (int k = 0; k < argc; ++k) ++k;
 
 #pragma omp target teams distribute parallel for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear(i)
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int v = 0;
-    int i;
-    #pragma omp target teams distribute parallel for simd linear(v:i)
-    for (int k = 0; k < argc; ++k) { i = k; v += i; }
-  }
-
-#pragma omp target teams distribute parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-  int v = 0;
-
-#pragma omp target teams distribute parallel for simd linear(v:j)
-  for (int k = 0; k < argc; ++k) { ++k; v += j; }
-
-#pragma omp target teams distribute parallel for simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
   return 0;
 }
 
@@ -198,15 +195,18 @@ int main(int argc, char **argv) {
 #pragma omp target teams distribute parallel for simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
 #pragma omp target teams distribute parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute parallel for simd linear (argc)
   for (int k = 0; k < argc; ++k) ++k;
 
@@ -226,22 +226,6 @@ int main(int argc, char **argv) {
 #pragma omp target teams distribute parallel for simd linear(h, C::x) // expected-error 2 {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int i;
-    #pragma omp target teams distribute parallel for simd linear(i)
-      for (int k = 0; k < argc; ++k) ++k;
-
-    #pragma omp target teams distribute parallel for simd linear(i : 4)
-      for (int k = 0; k < argc; ++k) { ++k; i += 4; }
-  }
-
-#pragma omp target teams distribute parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-#pragma omp target teams distribute parallel for simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
-
   foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
   return 0;
 }
diff --git a/clang/test/OpenMP/target_teams_distribute_simd_ast_print.cpp b/clang/test/OpenMP/target_teams_distribute_simd_ast_print.cpp
index 77732ef5601..31b9ad0c5fc 100644
--- a/clang/test/OpenMP/target_teams_distribute_simd_ast_print.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_simd_ast_print.cpp
@@ -28,8 +28,9 @@ public:
       ++this->a.a;
   }
   S7 &operator=(S7 &s) {
-#pragma omp target teams distribute simd private(a) private(this->a)
-    for (int k = 0; k < s.a.a; ++k)
+    int k;
+#pragma omp target teams distribute simd private(a) private(this->a) linear(k)
+    for (k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
@@ -50,7 +51,7 @@ public:
   }
 };
 // CHECK: #pragma omp target teams distribute simd private(this->a) private(this->a) private(T::a)
-// CHECK: #pragma omp target teams distribute simd private(this->a) private(this->a)
+// CHECK: #pragma omp target teams distribute simd private(this->a) private(this->a) linear(k)
 // CHECK: #pragma omp target teams distribute simd private(b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK: #pragma omp target teams distribute simd simdlen(slen1) safelen(slen2) aligned(arr: alen)
 // CHECK: #pragma omp target teams distribute simd private(this->a) private(this->a) private(this->S::a)
@@ -129,10 +130,10 @@ T tmain(T argc) {
 // CHECK: #pragma omp target teams distribute simd private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
-#pragma omp target teams distribute simd simdlen(clen-1) linear(d)
+#pragma omp target teams distribute simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
-// CHECK: #pragma omp target teams distribute simd simdlen(clen - 1) linear(d)
+// CHECK: #pragma omp target teams distribute simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target teams distribute simd safelen(clen-1) aligned(arr:alen)
@@ -180,10 +181,10 @@ int main (int argc, char **argv) {
 // CHECK: #pragma omp target teams distribute simd private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
-#pragma omp target teams distribute simd simdlen(clen-1) linear(d)
+#pragma omp target teams distribute simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
-// CHECK: #pragma omp target teams distribute simd simdlen(clen - 1) linear(d)
+// CHECK: #pragma omp target teams distribute simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target teams distribute simd safelen(clen-1) aligned(arr:N+6)
diff --git a/clang/test/OpenMP/target_teams_distribute_simd_linear_messages.cpp b/clang/test/OpenMP/target_teams_distribute_simd_linear_messages.cpp
index 8db57a0f366..2be792bbda7 100644
--- a/clang/test/OpenMP/target_teams_distribute_simd_linear_messages.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_simd_linear_messages.cpp
@@ -18,33 +18,42 @@ void test_linear_colons()
 {
   int B = 0;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(B:bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(B::ib:B:bfoo()) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(B:ib) // expected-error {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(z:B:ib) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'?}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(B:B::bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(X::x : ::z)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(B,::z, X::x)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(::z)
   for (int i = 0; i < 10; ++i) ;
 
 #pragma omp target teams distribute simd linear(B::bfoo()) // expected-error {{expected variable name}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+1 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
 }
@@ -65,6 +74,7 @@ template<int L, class T, class N> T test_template(T* arr, N num) {
 
 template<int LEN> int test_warn() {
   int ind2 = 0;
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
   #pragma omp target teams distribute simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
@@ -118,15 +128,18 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp target teams distribute simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
 #pragma omp target teams distribute simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear (argc : 5)
   for (int k = 0; k < argc; ++k) ++k;
 
@@ -139,33 +152,17 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp target teams distribute simd linear (argv[1]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(e, g)
   for (int k = 0; k < argc; ++k) ++k;
 
 #pragma omp target teams distribute simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear(i)
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int v = 0;
-    int i;
-    #pragma omp target teams distribute simd linear(v:i)
-    for (int k = 0; k < argc; ++k) { i = k; v += i; }
-  }
-
-#pragma omp target teams distribute simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-  int v = 0;
-
-#pragma omp target teams distribute simd linear(v:j)
-  for (int k = 0; k < argc; ++k) { ++k; v += j; }
-
-#pragma omp target teams distribute simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
   return 0;
 }
 
@@ -198,15 +195,18 @@ int main(int argc, char **argv) {
 #pragma omp target teams distribute simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
 #pragma omp target teams distribute simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+1 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target teams distribute simd linear (argc)
   for (int k = 0; k < argc; ++k) ++k;
 
@@ -226,22 +226,6 @@ int main(int argc, char **argv) {
 #pragma omp target teams distribute simd linear(h, C::x) // expected-error 2 {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int i;
-    #pragma omp target teams distribute simd linear(i)
-      for (int k = 0; k < argc; ++k) ++k;
-
-    #pragma omp target teams distribute simd linear(i : 4)
-      for (int k = 0; k < argc; ++k) { ++k; i += 4; }
-  }
-
-#pragma omp target teams distribute simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-#pragma omp target teams distribute simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
-
   foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
   return 0;
 }
diff --git a/clang/test/OpenMP/teams_distribute_parallel_for_simd_ast_print.cpp b/clang/test/OpenMP/teams_distribute_parallel_for_simd_ast_print.cpp
index 26cc1582294..7573fdeafa3 100644
--- a/clang/test/OpenMP/teams_distribute_parallel_for_simd_ast_print.cpp
+++ b/clang/test/OpenMP/teams_distribute_parallel_for_simd_ast_print.cpp
@@ -29,9 +29,10 @@ public:
       ++this->a.a;
   }
   S7 &operator=(S7 &s) {
+    int k;
 #pragma omp target
-#pragma omp teams distribute parallel for simd private(a) private(this->a)
-    for (int k = 0; k < s.a.a; ++k)
+#pragma omp teams distribute parallel for simd private(a) private(this->a) linear(k)
+    for (k = 0; k < s.a.a; ++k)
       ++s.a.a;
 
     foo();
@@ -59,7 +60,7 @@ public:
 // CHECK: #pragma omp target
 // CHECK-NEXT: #pragma omp teams distribute parallel for simd private(this->a) private(this->a) private(T::a)
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute parallel for simd private(this->a) private(this->a)
+// CHECK-NEXT: #pragma omp teams distribute parallel for simd private(this->a) private(this->a) linear(k)
 // CHECK: #pragma omp target
 // CHECK-NEXT: #pragma omp teams distribute parallel for simd default(none) private(b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK: #pragma omp target
@@ -161,11 +162,11 @@ T tmain(T argc) {
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
-#pragma omp teams distribute parallel for simd simdlen(clen-1) linear(d)
+#pragma omp teams distribute parallel for simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute parallel for simd simdlen(clen - 1) linear(d)
+// CHECK-NEXT: #pragma omp teams distribute parallel for simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
@@ -224,11 +225,11 @@ int main (int argc, char **argv) {
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
-#pragma omp teams distribute parallel for simd simdlen(clen-1) linear(d)
+#pragma omp teams distribute parallel for simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute parallel for simd simdlen(clen - 1) linear(d)
+// CHECK-NEXT: #pragma omp teams distribute parallel for simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
diff --git a/clang/test/OpenMP/teams_distribute_parallel_for_simd_linear_messages.cpp b/clang/test/OpenMP/teams_distribute_parallel_for_simd_linear_messages.cpp
index 5b91a3c4ccc..c0a9baf916d 100644
--- a/clang/test/OpenMP/teams_distribute_parallel_for_simd_linear_messages.cpp
+++ b/clang/test/OpenMP/teams_distribute_parallel_for_simd_linear_messages.cpp
@@ -18,34 +18,42 @@ void test_linear_colons()
 {
   int B = 0;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(B:bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(B::ib:B:bfoo()) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(B:ib) // expected-error {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(z:B:ib) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'?}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(B:B::bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(X::x : ::z)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(B,::z, X::x)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(::z)
   for (int i = 0; i < 10; ++i) ;
@@ -54,6 +62,7 @@ void test_linear_colons()
 #pragma omp teams distribute parallel for simd linear(B::bfoo()) // expected-error {{expected variable name}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
@@ -76,6 +85,7 @@ template<int L, class T, class N> T test_template(T* arr, N num) {
 
 template<int LEN> int test_warn() {
   int ind2 = 0;
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
   #pragma omp target
   #pragma omp teams distribute parallel for simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
@@ -133,10 +143,12 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute parallel for simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
@@ -145,6 +157,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear (argc : 5)
   for (int k = 0; k < argc; ++k) ++k;
@@ -161,6 +174,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute parallel for simd linear (argv[1]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(e, g)
   for (int k = 0; k < argc; ++k) ++k;
@@ -169,32 +183,11 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute parallel for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear(i)
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int v = 0;
-    int i;
-    #pragma omp target
-    #pragma omp teams distribute parallel for simd linear(v:i)
-    for (int k = 0; k < argc; ++k) { i = k; v += i; }
-  }
-
-#pragma omp target
-#pragma omp teams distribute parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-  int v = 0;
-
-#pragma omp target
-#pragma omp teams distribute parallel for simd linear(v:j)
-  for (int k = 0; k < argc; ++k) { ++k; v += j; }
-
-#pragma omp target
-#pragma omp teams distribute parallel for simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
   return 0;
 }
 
@@ -230,10 +223,12 @@ int main(int argc, char **argv) {
 #pragma omp teams distribute parallel for simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
@@ -242,6 +237,7 @@ int main(int argc, char **argv) {
 #pragma omp teams distribute parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd linear (argc)
   for (int k = 0; k < argc; ++k) ++k;
@@ -267,26 +263,6 @@ int main(int argc, char **argv) {
 #pragma omp teams distribute parallel for simd linear(h, C::x) // expected-error 2 {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int i;
-    #pragma omp target
-    #pragma omp teams distribute parallel for simd linear(i)
-      for (int k = 0; k < argc; ++k) ++k;
-
-    #pragma omp target
-    #pragma omp teams distribute parallel for simd linear(i : 4)
-      for (int k = 0; k < argc; ++k) { ++k; i += 4; }
-  }
-
-#pragma omp target
-#pragma omp teams distribute parallel for simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-#pragma omp target
-#pragma omp teams distribute parallel for simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
-
   foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
   return 0;
 }
diff --git a/clang/test/OpenMP/teams_distribute_simd_ast_print.cpp b/clang/test/OpenMP/teams_distribute_simd_ast_print.cpp
index aaf6745774c..e751413c423 100644
--- a/clang/test/OpenMP/teams_distribute_simd_ast_print.cpp
+++ b/clang/test/OpenMP/teams_distribute_simd_ast_print.cpp
@@ -29,9 +29,10 @@ public:
       ++this->a.a;
   }
   S7 &operator=(S7 &s) {
+    int k;
 #pragma omp target
-#pragma omp teams distribute simd private(a) private(this->a)
-    for (int k = 0; k < s.a.a; ++k)
+#pragma omp teams distribute simd private(a) private(this->a) linear(k)
+    for (k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
@@ -56,7 +57,7 @@ public:
 // CHECK: #pragma omp target
 // CHECK-NEXT: #pragma omp teams distribute simd private(this->a) private(this->a) private(T::a)
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute simd private(this->a) private(this->a)
+// CHECK-NEXT: #pragma omp teams distribute simd private(this->a) private(this->a) linear(k)
 // CHECK: #pragma omp target
 // CHECK-NEXT: #pragma omp teams distribute simd default(none) private(b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
 // CHECK: #pragma omp target
@@ -155,11 +156,11 @@ T tmain(T argc) {
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
-#pragma omp teams distribute simd simdlen(clen-1) linear(d)
+#pragma omp teams distribute simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute simd simdlen(clen - 1) linear(d)
+// CHECK-NEXT: #pragma omp teams distribute simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
@@ -218,11 +219,11 @@ int main (int argc, char **argv) {
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
-#pragma omp teams distribute simd simdlen(clen-1) linear(d)
+#pragma omp teams distribute simd simdlen(clen-1)
   for (int k = 0; k < 10; ++k)
     e += d + argc;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute simd simdlen(clen - 1) linear(d)
+// CHECK-NEXT: #pragma omp teams distribute simd simdlen(clen - 1)
 // CHECK-NEXT: for (int k = 0; k < 10; ++k)
 // CHECK-NEXT: e += d + argc;
 #pragma omp target
diff --git a/clang/test/OpenMP/teams_distribute_simd_linear_messages.cpp b/clang/test/OpenMP/teams_distribute_simd_linear_messages.cpp
index 6bfdb16274a..a53f0e62dda 100644
--- a/clang/test/OpenMP/teams_distribute_simd_linear_messages.cpp
+++ b/clang/test/OpenMP/teams_distribute_simd_linear_messages.cpp
@@ -18,34 +18,42 @@ void test_linear_colons()
 {
   int B = 0;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(B:bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(B::ib:B:bfoo()) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(B:ib) // expected-error {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(z:B:ib) // expected-error {{unexpected ':' in nested name specifier; did you mean '::'?}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(B:B::bfoo())
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(X::x : ::z)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 3 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(B,::z, X::x)
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(::z)
   for (int i = 0; i < 10; ++i) ;
@@ -54,6 +62,7 @@ void test_linear_colons()
 #pragma omp teams distribute simd linear(B::bfoo()) // expected-error {{expected variable name}}
   for (int i = 0; i < 10; ++i) ;
 
+// expected-error@+2 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
@@ -76,6 +85,7 @@ template<int L, class T, class N> T test_template(T* arr, N num) {
 
 template<int LEN> int test_warn() {
   int ind2 = 0;
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
   #pragma omp target
   #pragma omp teams distribute simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
@@ -133,10 +143,12 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
@@ -145,6 +157,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear (argc : 5)
   for (int k = 0; k < argc; ++k) ++k;
@@ -161,6 +174,7 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute simd linear (argv[1]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(e, g)
   for (int k = 0; k < argc; ++k) ++k;
@@ -169,32 +183,11 @@ template<class I, class C> int foomain(I argc, C **argv) {
 #pragma omp teams distribute simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear(i)
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int v = 0;
-    int i;
-    #pragma omp target
-    #pragma omp teams distribute simd linear(v:i)
-    for (int k = 0; k < argc; ++k) { i = k; v += i; }
-  }
-
-#pragma omp target
-#pragma omp teams distribute simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-  int v = 0;
-
-#pragma omp target
-#pragma omp teams distribute simd linear(v:j)
-  for (int k = 0; k < argc; ++k) { ++k; v += j; }
-
-#pragma omp target
-#pragma omp teams distribute simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
   return 0;
 }
 
@@ -230,10 +223,12 @@ int main(int argc, char **argv) {
 #pragma omp teams distribute simd linear () // expected-error {{expected expression}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int k = 0; k < argc; ++k) ++k;
@@ -242,6 +237,7 @@ int main(int argc, char **argv) {
 #pragma omp teams distribute simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (int k = 0; k < argc; ++k) ++k;
 
+// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
 #pragma omp target
 #pragma omp teams distribute simd linear (argc)
   for (int k = 0; k < argc; ++k) ++k;
@@ -267,26 +263,6 @@ int main(int argc, char **argv) {
 #pragma omp teams distribute simd linear(h, C::x) // expected-error 2 {{threadprivate or thread local variable cannot be linear}}
   for (int k = 0; k < argc; ++k) ++k;
 
-  #pragma omp parallel
-  {
-    int i;
-    #pragma omp target
-    #pragma omp teams distribute simd linear(i)
-      for (int k = 0; k < argc; ++k) ++k;
-
-    #pragma omp target
-    #pragma omp teams distribute simd linear(i : 4)
-      for (int k = 0; k < argc; ++k) { ++k; i += 4; }
-  }
-
-#pragma omp target
-#pragma omp teams distribute simd linear(j)
-  for (int k = 0; k < argc; ++k) ++k;
-
-#pragma omp target
-#pragma omp teams distribute simd linear(i)
-  for (int k = 0; k < argc; ++k) ++k;
-
   foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
   return 0;
 }