[Clang][OpenMP] Allow loop iteration var with threadprivate directive

[jyu2]

Summary

Loop iteration var with threadprivate is predetermined as threadprivate.

Current clang emit error when loop var that appear in threadprivate
directives.

According to OpenMP 5.1 [2.21.1.1]

For first predetermined rule is:
Variables that appear in threadprivate directives or variables with the
_Thread_local (in C) or thread_local (in C++) storage-class specifier
are threadprivate

The error should not be emitted.

To fix this, add two line condition to check OMPC_threadprivate for the loops.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

8660

Why need this change?

8669–8674

Again, why do we need this?

[jyu2]

Hi Alexey, Thanks for review.

clang/lib/Sema/SemaOpenMP.cpp

8660

The rule:
The loop iteration variable in any associated loop of a loop construct is lastprivate.

So if there is lastprivate clause, should be predetermined as lastprivate.

8669–8674

In the comment: for OpenMP 5.0 and up:

If a simd construct has just one associated loop, the variable may be listed in a private, lastprivate or linear.

The linear part is set on line 8652, there just need to set private and lastprivate.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

8660

The patch is for threadprivates, better to do it in a separate patch(or patches).

8669–8674

Same here, better to split this change

[jyu2]

clang/lib/Sema/SemaOpenMP.cpp

8660

That is already there but in different in the if statement on line 8657 in old code:

DVar.CKind != OMPC_lastprivate)) &

I just want to merge that into PredetermindCKind.

8669–8674

It is also in old code on line 8650: I just want to merge them into PredetermindCKind.

(LangOpts.OpenMP <= 45 || (DVar.CKind != OMPC_lastprivate &&

DVar.CKind != OMPC_private)))

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

8660

Can you do it in a separate NFC patch (if this is actually NFC)?

[jyu2]

clang/lib/Sema/SemaOpenMP.cpp

8660

Okay, will do in sperate change.

[ABataev]

LG with a nit.

clang/lib/Sema/SemaOpenMP.cpp

8658

Need to fix the formatting.

[lebedev.ri]

In which standard version was that rule introduced, is this missing some checks for the OpenMP version?

[jyu2]

In D112292#3080945, @lebedev.ri wrote:

In which standard version was that rule introduced, is this missing some checks for the OpenMP version?

I check back to omp 45, the rule was there.

[jyu2]

fix format problem.

[dreachem]

There still exists a restriction that the loop variable must not be threadprivate in OpenMP 5.1. See Canonical Loop Nest restrictions, p125, line 7:

The loop iteration variable may not appear in a threadprivate directive.

[jyu2]

Good point. I did not find that. At this point, I don't know if we need this change. I checked gnu, gnu allow this.... :-(

clang/lib/Sema/SemaOpenMP.cpp

if (!ISC.checkAndSetInit(Init, /*EmitDiags=*/false)) {
         // is declared in the loop and it is predetermined as a private.
         Expr *LoopDeclRefExpr = ISC.getLoopDeclRefExpr();
         OpenMPClauseKind PredeterminedCKind =
             isOpenMPSimdDirective(DKind)
                 ? (DSAStack->hasMutipleLoops() ? OMPC_lastprivate : OMPC_linear)
                 : OMPC_private;
         if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
               DVar.CKind != PredeterminedCKind && DVar.RefExpr &&
+              DVar.CKind != OMPC_threadprivate &&
               (LangOpts.OpenMP <= 45 || (DVar.CKind != OMPC_lastprivate &&
                                          DVar.CKind != OMPC_private))) ||
              ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop ||
                DKind == OMPD_master_taskloop ||
                DKind == OMPD_parallel_master_taskloop ||
                isOpenMPDistributeDirective(DKind)) &&
               !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
-              DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) &&
+              DVar.CKind != OMPC_threadprivate && DVar.CKind != OMPC_private &&
+              DVar.CKind != OMPC_lastprivate)) &&
             (DVar.CKind != OMPC_private || DVar.RefExpr)) {
           Diag(Init->getBeginLoc(), diag::err_omp_loop_var_dsa)
               << getOpenMPClauseName(DVar.CKind)
               << getOpenMPDirectiveName(DKind)
               << getOpenMPClauseName(PredeterminedCKind);
           if (DVar.RefExpr == nullptr)
             DVar.CKind = PredeterminedCKind;
           reportOriginalDsa(*this, DSAStack, D, DVar,
                             /*IsLoopIterVar=*/true);
         } else if (LoopDeclRefExpr) {
           // Make the loop iteration variable private (for worksharing
           // constructs), linear (for simd directives with the only one
           // associated loop) or lastprivate (for simd directives with several
           // collapsed or ordered loops).
           if (DVar.CKind == OMPC_unknown)
             DSAStack->addDSA(D, LoopDeclRefExpr, PredeterminedCKind,
                              PrivateRef);
         }
       }
     }
     DSAStack->setAssociatedLoops(AssociatedLoops - 1);
   }
 }

clang/test/OpenMP/distribute_parallel_for_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 #pragma omp teams
 // omp4-note@+2 {{defined as lastprivate}}
 // omp4-error@+2 {{loop iteration variable in the associated loop of 'omp distribute parallel for simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp distribute parallel for simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp distribute parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp distribute parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp distribute parallel for simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
   {
 #pragma omp distribute parallel for simd
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/distribute_simd_loop_messages.cpp

 #pragma omp distribute simd
     for (int k = 0; k < s.a; ++k) // expected-warning {{Type 'S5' is not trivially copyable and not guaranteed to be mapped correctly}}
       ++s.a;
     return *this;
   }
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
int test_iteration_spaces() {
   for (jj = 0; jj < 10; jj++) // expected-error {{loop iteration variable in the associated loop of 'omp distribute simd' directive may not be linear, predetermined as lastprivate}}
     c[ii] = a[jj];
 
 
   #pragma omp parallel
   {
     #pragma omp target
     #pragma omp teams
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp distribute simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp distribute simd' directive may not be threadprivate or thread local, predetermined as linear}}
     #pragma omp distribute simd
     for (sii = 0; sii < 10; sii+=1)
       c[sii] = a[sii];
   }
 
   #pragma omp parallel
   {
     #pragma omp target

clang/test/OpenMP/for_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected@+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 
 #pragma omp parallel
 #pragma omp for lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// not error expected@+2 {{loop iteration variable in the associated loop of 'omp for' directive may not be threadprivate or thread local, predetermined as private}}
 #pragma omp for
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp for

clang/test/OpenMP/for_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 // omp4-note@+2  {{defined as lastprivate}}
 // omp4-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp for simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp for simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp for simd

clang/test/OpenMP/master_taskloop_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected@+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 
 #pragma omp parallel
 #pragma omp master taskloop lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp master taskloop' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// not error expected@+2 {{loop iteration variable in the associated loop of 'omp master taskloop' directive may not be threadprivate or thread local, predetermined as private}}
 #pragma omp master taskloop
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp master taskloop

clang/test/OpenMP/master_taskloop_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 // omp4-error@+3 {{loop iteration variable in the associated loop of 'omp master taskloop simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp parallel
 #pragma omp master taskloop simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp master taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp master taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp master taskloop simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp master taskloop simd

clang/test/OpenMP/parallel_for_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
#pragma omp parallel for private(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel for lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be threadprivate or thread local, predetermined as private}}
 #pragma omp parallel for
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
   {
 #pragma omp parallel for
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/parallel_for_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 
 // omp4-note@+2 {{defined as lastprivate}}
 // omp4-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp parallel for simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp parallel for simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
   {
 #pragma omp parallel for simd
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/parallel_master_taskloop_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 
 #pragma omp parallel
 #pragma omp parallel master taskloop lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel master taskloop' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp parallel master taskloop' directive may not be threadprivate or thread local, predetermined as private}}
 #pragma omp parallel master taskloop
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp parallel master taskloop

clang/test/OpenMP/parallel_master_taskloop_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 
 #pragma omp parallel
 #pragma omp parallel master taskloop simd linear(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel master taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp parallel master taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp parallel master taskloop simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp parallel master taskloop simd

clang/test/OpenMP/simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4,expectedw %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4,expectedw %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5,expectedw %s -fopenmp-version=50 -DOMP50 -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5,expectedw %s -fopenmp-version=50 -DOMP50 -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized -Wno-openmp-loop-form
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized -Wno-openmp
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 struct S {
   // expected-note@+1 {{static data member is predetermined as shared}}
   static int ssi;
 };
 
#endif // OMP50
   #pragma omp simd lastprivate(ii) linear(jj) collapse(2) // expected-note {{defined as linear}}
   for (ii = 0; ii < 10; ii++)
   for (jj = 0; jj < 10; jj++) // expected-error {{loop iteration variable in the associated loop of 'omp simd' directive may not be linear, predetermined as lastprivate}}
     c[ii] = a[jj];
 
 
   #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be threadprivate or thread local, predetermined as linear}}
     #pragma omp simd
     for (sii = 0; sii < 10; sii+=1)
       c[sii] = a[sii];
   }
 
   #pragma omp parallel
   {
     #pragma omp simd

clang/test/OpenMP/target_parallel_for_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
#pragma omp target parallel for private(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target parallel for lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp target parallel for' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp target parallel for' directive may not be threadprivate or thread local, predetermined as private}}
 #pragma omp target parallel for
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
   {
 #pragma omp target parallel for
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/target_parallel_for_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp50 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp50 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 
 // omp45-note@+2  {{defined as lastprivate}}
 // omp45-error@+2 {{loop iteration variable in the associated loop of 'omp target parallel for simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp target parallel for simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp target parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp target parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp target parallel for simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
   {
 #pragma omp target parallel for simd
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/target_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp50 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp50 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 
 // omp45-note@+2  {{defined as lastprivate}}
 // omp45-error@+2 {{loop iteration variable in the associated loop of 'omp target simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp target simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp target simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp target simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp target simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
   {
 #pragma omp target simd
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/target_teams_distribute_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target teams distribute lastprivate(ii)
 // OK
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target teams distribute
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp target teams distribute' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp target teams distribute' directive may not be threadprivate or thread local, predetermined as private}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target teams distribute collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)
       c[globalii] += a[globalii] + ii;

clang/test/OpenMP/target_teams_distribute_parallel_for_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
#pragma omp target teams distribute parallel for private(ii) // OK
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target teams distribute parallel for lastprivate(ii) // OK
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target teams distribute parallel for
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp target teams distribute parallel for' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp target teams distribute parallel for' directive may not be threadprivate or thread local, predetermined as private}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target teams distribute parallel for collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)
       c[globalii] += a[globalii] + ii;

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp50 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp50 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
#pragma omp target teams distribute parallel for simd private(ii) // omp45-note {{defined as private}}
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 // omp45-error@+2 {{loop iteration variable in the associated loop of 'omp target teams distribute parallel for simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp target teams distribute parallel for simd lastprivate(ii) // omp45-note {{defined as lastprivate}}
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp target teams distribute parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp target teams distribute parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp target teams distribute parallel for simd
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target teams distribute parallel for simd collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/target_teams_distribute_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wno-openmp-mapping -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;
for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target teams distribute simd lastprivate(ii) // omp4-note {{defined as lastprivate}}
 // omp4-error@+1 {{loop iteration variable in the associated loop of 'omp target teams distribute simd' directive may not be lastprivate, predetermined as linear}}
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target teams distribute simd
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp target teams distribute simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp target teams distribute simd' directive may not be threadprivate or thread local, predetermined as linear}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target teams distribute simd collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)
       c[globalii] += a[globalii] + ii;

clang/test/OpenMP/taskloop_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected@+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 
 #pragma omp parallel
 #pragma omp taskloop lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp taskloop' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp taskloop' directive may not be threadprivate or thread local, predetermined as private}}
 #pragma omp taskloop
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp taskloop

clang/test/OpenMP/taskloop_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 // Currently, we cannot use "0" for global register variables.
 // register int reg0 __asm__("0");
 int reg0;
 
 int test_iteration_spaces() {

 // omp4-error@+3 {{loop iteration variable in the associated loop of 'omp taskloop simd' directive may not be lastprivate, predetermined as linear}}
 #pragma omp parallel
 #pragma omp taskloop simd lastprivate(ii)
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp parallel
   {
-// expected-error@+2 {{loop iteration variable in the associated loop of 'omp taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+2 {{loop iteration variable in the associated loop of 'omp taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
 #pragma omp taskloop simd
     for (sii = 0; sii < 10; sii += 1)
       c[sii] = a[sii];
   }
 
 #pragma omp parallel
   {
 #pragma omp taskloop simd

clang/test/OpenMP/teams_distribute_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 #pragma omp target
 #pragma omp teams distribute lastprivate(ii)
 // OK
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target
 #pragma omp teams distribute
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp teams distribute' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp teams distribute' directive may not be threadprivate or thread local, predetermined as private}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target
 #pragma omp teams distribute collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/teams_distribute_parallel_for_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 
 #pragma omp target
 #pragma omp teams distribute parallel for lastprivate(ii) // OK
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target
 #pragma omp teams distribute parallel for
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp teams distribute parallel for' directive may not be threadprivate or thread local, predetermined as private}}
+// loop var with threadprivate or thread local is predetermined as threadprivate
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp teams distribute parallel for' directive may not be threadprivate or thread local, predetermined as private}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target
 #pragma omp teams distribute parallel for collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/teams_distribute_parallel_for_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 #pragma omp target
 #pragma omp teams distribute parallel for simd lastprivate(ii) // omp4-note {{defined as lastprivate}}
 // omp4-error@+1 {{loop iteration variable in the associated loop of 'omp teams distribute parallel for simd' directive may not be lastprivate, predetermined as linear}}
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target
 #pragma omp teams distribute parallel for simd
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp teams distribute parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp teams distribute parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target
 #pragma omp teams distribute parallel for simd collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)

clang/test/OpenMP/teams_distribute_simd_loop_messages.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
 
 class S {
   int a;
   S() : a(0) {} // expected-note {{implicitly declared private here}}
 
 public:
   S(int v) : a(v) {}
   S(const S &s) : a(s.a) {}
 };
 
 static int sii;
-// expected-note@+1 {{defined as threadprivate or thread local}}
+// no note expected @+1 {{defined as threadprivate or thread local}}
 #pragma omp threadprivate(sii)
 static int globalii;
 
 int test_iteration_spaces() {
   const int N = 100;
   float a[N], b[N], c[N];
   int ii, jj, kk;
   float fii;

 #pragma omp target
 #pragma omp teams distribute simd lastprivate(ii) // omp4-note {{defined as lastprivate}}
 // omp4-error@+1 {{loop iteration variable in the associated loop of 'omp teams distribute simd' directive may not be lastprivate, predetermined as linear}}
   for (ii = 0; ii < 10; ii++)
     c[ii] = a[ii];
 
 #pragma omp target
 #pragma omp teams distribute simd
-// expected-error@+1 {{loop iteration variable in the associated loop of 'omp teams distribute simd' directive may not be threadprivate or thread local, predetermined as linear}}
+// no error expected @+1 {{loop iteration variable in the associated loop of 'omp teams distribute simd' directive may not be threadprivate or thread local, predetermined as linear}}
   for (sii = 0; sii < 10; sii++)
     c[sii] = a[sii];
 
   {
 #pragma omp target
 #pragma omp teams distribute simd collapse(2)
   for (ii = 0; ii < 10; ii += 1)
     for (globalii = 0; globalii < 10; globalii += 1)