r248880 - [OPENMP 4.1] Sema analysis for array sections in 'reduction' clause.

[Alexey Bataev via cfe-commits]

Author: abataev
Date: Wed Sep 30 04:22:36 2015
New Revision: 248880

URL: http://llvm.org/viewvc/llvm-project?rev=248880&view=rev
Log:
[OPENMP 4.1] Sema analysis for array sections in 'reduction' clause.
OpenMP 4.1 allows to use array sections|subscript expressions in 'reduction' 
clauses. Added sema analysis, updated tests.

Modified:
    cfe/trunk/include/clang/AST/ExprOpenMP.h
    cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
    cfe/trunk/lib/AST/Expr.cpp
    cfe/trunk/lib/Sema/SemaExpr.cpp
    cfe/trunk/lib/Sema/SemaOpenMP.cpp
    cfe/trunk/test/OpenMP/for_reduction_messages.cpp
    cfe/trunk/test/OpenMP/for_simd_reduction_messages.cpp
    cfe/trunk/test/OpenMP/parallel_ast_print.cpp
    cfe/trunk/test/OpenMP/parallel_for_reduction_messages.cpp
    cfe/trunk/test/OpenMP/parallel_for_simd_reduction_messages.cpp
    cfe/trunk/test/OpenMP/parallel_reduction_messages.cpp
    cfe/trunk/test/OpenMP/parallel_sections_reduction_messages.cpp
    cfe/trunk/test/OpenMP/sections_reduction_messages.cpp
    cfe/trunk/test/OpenMP/simd_reduction_messages.cpp
    cfe/trunk/test/OpenMP/teams_reduction_messages.cpp

Modified: cfe/trunk/include/clang/AST/ExprOpenMP.h
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/ExprOpenMP.h?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/include/clang/AST/ExprOpenMP.h (original)
+++ cfe/trunk/include/clang/AST/ExprOpenMP.h Wed Sep 30 04:22:36 2015
@@ -84,6 +84,9 @@ public:
   /// \brief Set base of the array section.
   void setBase(Expr *E) { SubExprs[BASE] = E; }
 
+  /// \brief Return original type of the base expression for array section.
+  static QualType getBaseOriginalType(Expr *Base);
+
   /// \brief Get lower bound of array section.
   Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
   const Expr *getLowerBound() const {

Modified: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td (original)
+++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td Wed Sep 30 04:22:36 
2015
@@ -7508,7 +7508,7 @@ def err_omp_firstprivate_incomplete_type
 def err_omp_lastprivate_incomplete_type : Error<
   "a lastprivate variable with incomplete type %0">;
 def err_omp_reduction_incomplete_type : Error<
-  "a reduction variable with incomplete type %0">;
+  "a reduction list item with incomplete type %0">;
 def err_omp_unexpected_clause_value : Error<
   "expected %0 in OpenMP clause '%1'">;
 def err_omp_expected_var_name : Error<
@@ -7565,6 +7565,8 @@ def err_omp_required_access : Error<
   "%0 variable must be %1">;
 def err_omp_const_variable : Error<
   "const-qualified variable cannot be %0">;
+def err_omp_const_reduction_list_item : Error<
+  "const-qualified list item cannot be reduction">;
 def err_omp_linear_incomplete_type : Error<
   "a linear variable with incomplete type %0">;
 def err_omp_linear_expected_int_or_ptr : Error<
@@ -7616,7 +7618,7 @@ def warn_omp_loop_64_bit_var : Warning<
 def err_omp_unknown_reduction_identifier : Error<
   "incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', 
'^', '&&', '||', 'min' or 'max'">;
 def err_omp_reduction_type_array : Error<
-  "a reduction variable with array type %0">;
+  "a reduction list item with array type %0">;
 def err_omp_reduction_ref_type_arg : Error<
   "argument of OpenMP clause 'reduction' must reference the same object in all 
threads">;
 def err_omp_clause_not_arithmetic_type_arg : Error<
@@ -7630,7 +7632,7 @@ def note_omp_referenced : Note<
 def err_omp_reduction_in_task : Error<
   "reduction variables may not be accessed in an explicit task">;
 def err_omp_reduction_id_not_compatible : Error<
-  "variable of type %0 is not valid for specified reduction operation: unable 
to provide default initialization value">;
+  "list item of type %0 is not valid for specified reduction operation: unable 
to provide default initialization value">;
 def err_omp_prohibited_region : Error<
   "region cannot be%select{| closely}0 nested inside '%1' region"
   "%select{|; perhaps you forget to enclose 'omp %3' directive into a parallel 
region?|"
@@ -7738,6 +7740,8 @@ def err_omp_ordered_directive_with_param
   "'ordered' directive %select{without any clauses|with 'threads' clause}0 
cannot be closely nested inside ordered region with specified parameter">;
 def note_omp_ordered_param : Note<
   "'ordered' clause with specified parameter">;
+def err_omp_expected_array_sect_reduction_lb_not_zero : Error<
+  "lower bound expected to be evaluated to zero">;
 } // end of OpenMP category
 
 let CategoryName = "Related Result Type Issue" in {

Modified: cfe/trunk/lib/AST/Expr.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Expr.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/lib/AST/Expr.cpp (original)
+++ cfe/trunk/lib/AST/Expr.cpp Wed Sep 30 04:22:36 2015
@@ -3977,3 +3977,26 @@ unsigned AtomicExpr::getNumSubExprs(Atom
   }
   llvm_unreachable("unknown atomic op");
 }
+
+QualType OMPArraySectionExpr::getBaseOriginalType(Expr *Base) {
+  unsigned ArraySectionCount = 0;
+  while (auto *OASE = dyn_cast<OMPArraySectionExpr>(Base->IgnoreParens())) {
+    Base = OASE->getBase();
+    ++ArraySectionCount;
+  }
+  auto OriginalTy = Base->getType();
+  if (auto *DRE = dyn_cast<DeclRefExpr>(Base))
+    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
+      OriginalTy = PVD->getOriginalType().getNonReferenceType();
+
+  for (unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
+    if (OriginalTy->isAnyPointerType())
+      OriginalTy = OriginalTy->getPointeeType();
+    else {
+      assert (OriginalTy->isArrayType());
+      OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
+    }
+  }
+  return OriginalTy;
+}
+

Modified: cfe/trunk/lib/Sema/SemaExpr.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaExpr.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaExpr.cpp (original)
+++ cfe/trunk/lib/Sema/SemaExpr.cpp Wed Sep 30 04:22:36 2015
@@ -3987,28 +3987,6 @@ Sema::ActOnArraySubscriptExpr(Scope *S,
   return CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc);
 }
 
-static QualType getNonOMPArraySectionType(Expr *Base) {
-  unsigned ArraySectionCount = 0;
-  while (auto *OASE = dyn_cast<OMPArraySectionExpr>(Base->IgnoreParens())) {
-    Base = OASE->getBase();
-    ++ArraySectionCount;
-  }
-  auto OriginalTy = Base->getType();
-  if (auto *DRE = dyn_cast<DeclRefExpr>(Base))
-    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
-      OriginalTy = PVD->getOriginalType().getNonReferenceType();
-
-  for (unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
-    if (OriginalTy->isAnyPointerType())
-      OriginalTy = OriginalTy->getPointeeType();
-    else {
-      assert (OriginalTy->isArrayType());
-      OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
-    }
-  }
-  return OriginalTy;
-}
-
 ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
                                           Expr *LowerBound,
                                           SourceLocation ColonLoc, Expr 
*Length,
@@ -4045,7 +4023,7 @@ ExprResult Sema::ActOnOMPArraySectionExp
   }
 
   // Perform default conversions.
-  QualType OriginalTy = getNonOMPArraySectionType(Base);
+  QualType OriginalTy = OMPArraySectionExpr::getBaseOriginalType(Base);
   QualType ResultTy;
   if (OriginalTy->isAnyPointerType()) {
     ResultTy = OriginalTy->getPointeeType();

Modified: cfe/trunk/lib/Sema/SemaOpenMP.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaOpenMP.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaOpenMP.cpp (original)
+++ cfe/trunk/lib/Sema/SemaOpenMP.cpp Wed Sep 30 04:22:36 2015
@@ -6390,14 +6390,39 @@ OMPClause *Sema::ActOnOpenMPReductionCla
     // OpenMP  [2.14.3.3, Restrictions, p.1]
     //  A variable that is part of another variable (as an array or
     //  structure element) cannot appear in a private clause.
-    auto DE = dyn_cast<DeclRefExpr>(RefExpr);
-    if (!DE || !isa<VarDecl>(DE->getDecl())) {
-      Diag(ELoc, diag::err_omp_expected_var_name) << ERange;
+    auto *DE = dyn_cast<DeclRefExpr>(RefExpr);
+    auto *ASE = dyn_cast<ArraySubscriptExpr>(RefExpr);
+    auto *OASE = dyn_cast<OMPArraySectionExpr>(RefExpr);
+    if (!ASE && !OASE && (!DE || !isa<VarDecl>(DE->getDecl()))) {
+      Diag(ELoc, diag::err_omp_expected_var_name_or_array_item) << ERange;
       continue;
     }
-    auto D = DE->getDecl();
-    auto VD = cast<VarDecl>(D);
-    auto Type = VD->getType();
+    QualType Type;
+    VarDecl *VD = nullptr;
+    if (DE) {
+      auto D = DE->getDecl();
+      VD = cast<VarDecl>(D);
+      Type = VD->getType();
+    } else if (ASE)
+      Type = ASE->getType();
+    else if (OASE) {
+      auto BaseType = 
OMPArraySectionExpr::getBaseOriginalType(OASE->getBase());
+      if (auto *ATy = BaseType->getAsArrayTypeUnsafe())
+        Type = ATy->getElementType();
+      else
+        Type = BaseType->getPointeeType();
+    }
+    // OpenMP [2.15.3.6, reduction Clause]
+    // If a list item is an array section, its lower-bound must be zero.
+    llvm::APSInt Result;
+    if (OASE && OASE->getLowerBound() &&
+        OASE->getLowerBound()->EvaluateAsInt(Result, Context) && Result != 0) {
+      Diag(OASE->getLowerBound()->getExprLoc(),
+           diag::err_omp_expected_array_sect_reduction_lb_not_zero)
+          << OASE->getLowerBound()->getSourceRange();
+      continue;
+    }
+
     // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
     //  A variable that appears in a private clause must not have an incomplete
     //  type or a reference type.
@@ -6408,36 +6433,42 @@ OMPClause *Sema::ActOnOpenMPReductionCla
     // Arrays may not appear in a reduction clause.
     if (Type.getNonReferenceType()->isArrayType()) {
       Diag(ELoc, diag::err_omp_reduction_type_array) << Type << ERange;
-      bool IsDecl =
-          VD->isThisDeclarationADefinition(Context) == 
VarDecl::DeclarationOnly;
-      Diag(VD->getLocation(),
-           IsDecl ? diag::note_previous_decl : diag::note_defined_here)
-          << VD;
+      if (VD) {
+        bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
+                      VarDecl::DeclarationOnly;
+        Diag(VD->getLocation(),
+             IsDecl ? diag::note_previous_decl : diag::note_defined_here)
+            << VD;
+      }
       continue;
     }
     // OpenMP [2.14.3.6, reduction clause, Restrictions]
     // A list item that appears in a reduction clause must not be
     // const-qualified.
     if (Type.getNonReferenceType().isConstant(Context)) {
-      Diag(ELoc, diag::err_omp_const_variable)
+      Diag(ELoc, diag::err_omp_const_reduction_list_item)
           << getOpenMPClauseName(OMPC_reduction) << Type << ERange;
-      bool IsDecl =
-          VD->isThisDeclarationADefinition(Context) == 
VarDecl::DeclarationOnly;
-      Diag(VD->getLocation(),
-           IsDecl ? diag::note_previous_decl : diag::note_defined_here)
-          << VD;
+      if (VD) {
+        bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
+                      VarDecl::DeclarationOnly;
+        Diag(VD->getLocation(),
+             IsDecl ? diag::note_previous_decl : diag::note_defined_here)
+            << VD;
+      }
       continue;
     }
     // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]
     //  If a list-item is a reference type then it must bind to the same object
     //  for all threads of the team.
-    VarDecl *VDDef = VD->getDefinition();
-    if (Type->isReferenceType() && VDDef) {
-      DSARefChecker Check(DSAStack);
-      if (Check.Visit(VDDef->getInit())) {
-        Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange;
-        Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
-        continue;
+    if (VD) {
+      VarDecl *VDDef = VD->getDefinition();
+      if (Type->isReferenceType() && VDDef) {
+        DSARefChecker Check(DSAStack);
+        if (Check.Visit(VDDef->getInit())) {
+          Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange;
+          Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
+          continue;
+        }
       }
     }
     // OpenMP [2.14.3.6, reduction clause, Restrictions]
@@ -6453,21 +6484,25 @@ OMPClause *Sema::ActOnOpenMPReductionCla
           (getLangOpts().CPlusPlus && Type->isArithmeticType()))) {
       Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg)
           << getLangOpts().CPlusPlus;
-      bool IsDecl =
-          VD->isThisDeclarationADefinition(Context) == 
VarDecl::DeclarationOnly;
-      Diag(VD->getLocation(),
-           IsDecl ? diag::note_previous_decl : diag::note_defined_here)
-          << VD;
+      if (VD) {
+        bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
+                      VarDecl::DeclarationOnly;
+        Diag(VD->getLocation(),
+             IsDecl ? diag::note_previous_decl : diag::note_defined_here)
+            << VD;
+      }
       continue;
     }
     if ((BOK == BO_OrAssign || BOK == BO_AndAssign || BOK == BO_XorAssign) &&
         !getLangOpts().CPlusPlus && Type->isFloatingType()) {
       Diag(ELoc, diag::err_omp_clause_floating_type_arg);
-      bool IsDecl =
-          VD->isThisDeclarationADefinition(Context) == 
VarDecl::DeclarationOnly;
-      Diag(VD->getLocation(),
-           IsDecl ? diag::note_previous_decl : diag::note_defined_here)
-          << VD;
+      if (VD) {
+        bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
+                      VarDecl::DeclarationOnly;
+        Diag(VD->getLocation(),
+             IsDecl ? diag::note_previous_decl : diag::note_defined_here)
+            << VD;
+      }
       continue;
     }
     // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
@@ -6481,42 +6516,49 @@ OMPClause *Sema::ActOnOpenMPReductionCla
     //  Any number of reduction clauses can be specified on the directive,
     //  but a list item can appear only once in the reduction clauses for that
     //  directive.
-    DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(VD, false);
-    if (DVar.CKind == OMPC_reduction) {
-      Diag(ELoc, diag::err_omp_once_referenced)
-          << getOpenMPClauseName(OMPC_reduction);
-      if (DVar.RefExpr) {
-        Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);
-      }
-    } else if (DVar.CKind != OMPC_unknown) {
-      Diag(ELoc, diag::err_omp_wrong_dsa)
-          << getOpenMPClauseName(DVar.CKind)
-          << getOpenMPClauseName(OMPC_reduction);
-      ReportOriginalDSA(*this, DSAStack, VD, DVar);
-      continue;
+    DSAStackTy::DSAVarData DVar;
+    if (VD) {
+      DVar = DSAStack->getTopDSA(VD, false);
+      if (DVar.CKind == OMPC_reduction) {
+        Diag(ELoc, diag::err_omp_once_referenced)
+            << getOpenMPClauseName(OMPC_reduction);
+        if (DVar.RefExpr) {
+          Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);
+        }
+      } else if (DVar.CKind != OMPC_unknown) {
+        Diag(ELoc, diag::err_omp_wrong_dsa)
+            << getOpenMPClauseName(DVar.CKind)
+            << getOpenMPClauseName(OMPC_reduction);
+        ReportOriginalDSA(*this, DSAStack, VD, DVar);
+        continue;
+      }
     }
 
     // OpenMP [2.14.3.6, Restrictions, p.1]
     //  A list item that appears in a reduction clause of a worksharing
     //  construct must be shared in the parallel regions to which any of the
     //  worksharing regions arising from the worksharing construct bind.
-    OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
-    if (isOpenMPWorksharingDirective(CurrDir) &&
-        !isOpenMPParallelDirective(CurrDir)) {
-      DVar = DSAStack->getImplicitDSA(VD, true);
-      if (DVar.CKind != OMPC_shared) {
-        Diag(ELoc, diag::err_omp_required_access)
-            << getOpenMPClauseName(OMPC_reduction)
-            << getOpenMPClauseName(OMPC_shared);
-        ReportOriginalDSA(*this, DSAStack, VD, DVar);
-        continue;
+    if (VD) {
+      OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
+      if (isOpenMPWorksharingDirective(CurrDir) &&
+          !isOpenMPParallelDirective(CurrDir)) {
+        DVar = DSAStack->getImplicitDSA(VD, true);
+        if (DVar.CKind != OMPC_shared) {
+          Diag(ELoc, diag::err_omp_required_access)
+              << getOpenMPClauseName(OMPC_reduction)
+              << getOpenMPClauseName(OMPC_shared);
+          ReportOriginalDSA(*this, DSAStack, VD, DVar);
+          continue;
+        }
       }
     }
     Type = Type.getNonLValueExprType(Context).getUnqualifiedType();
-    auto *LHSVD = buildVarDecl(*this, ELoc, Type, ".reduction.lhs",
-                               VD->hasAttrs() ? &VD->getAttrs() : nullptr);
-    auto *RHSVD = buildVarDecl(*this, ELoc, Type, VD->getName(),
-                               VD->hasAttrs() ? &VD->getAttrs() : nullptr);
+    auto *LHSVD =
+        buildVarDecl(*this, ELoc, Type, ".reduction.lhs",
+                     VD && VD->hasAttrs() ? &VD->getAttrs() : nullptr);
+    auto *RHSVD =
+        buildVarDecl(*this, ELoc, Type, VD ? VD->getName() : ".item.",
+                     VD && VD->hasAttrs() ? &VD->getAttrs() : nullptr);
     // Add initializer for private variable.
     Expr *Init = nullptr;
     switch (BOK) {
@@ -6631,11 +6673,13 @@ OMPClause *Sema::ActOnOpenMPReductionCla
     if (!RHSVD->hasInit()) {
       Diag(ELoc, diag::err_omp_reduction_id_not_compatible) << Type
                                                             << 
ReductionIdRange;
-      bool IsDecl =
-          VD->isThisDeclarationADefinition(Context) == 
VarDecl::DeclarationOnly;
-      Diag(VD->getLocation(),
-           IsDecl ? diag::note_previous_decl : diag::note_defined_here)
-          << VD;
+      if (VD) {
+        bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
+                      VarDecl::DeclarationOnly;
+        Diag(VD->getLocation(),
+             IsDecl ? diag::note_previous_decl : diag::note_defined_here)
+            << VD;
+      }
       continue;
     }
     auto *LHSDRE = buildDeclRefExpr(*this, LHSVD, Type, ELoc);
@@ -6661,8 +6705,9 @@ OMPClause *Sema::ActOnOpenMPReductionCla
     if (ReductionOp.isInvalid())
       continue;
 
-    DSAStack->addDSA(VD, DE, OMPC_reduction);
-    Vars.push_back(DE);
+    if (VD)
+      DSAStack->addDSA(VD, DE, OMPC_reduction);
+    Vars.push_back(RefExpr);
     LHSs.push_back(LHSDRE);
     RHSs.push_back(RHSDRE);
     ReductionOps.push_back(ReductionOp.get());

Modified: cfe/trunk/test/OpenMP/for_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/for_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/for_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/for_reduction_messages.cpp Wed Sep 30 04:22:36 2015
@@ -128,27 +128,27 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(+ : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 3 {{const-qualified 
variable cannot be reduction}} expected-error 3 {{'operator+' is a private 
member of 'S2'}}
+#pragma omp for reduction(+ : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 3 {{const-qualified list 
item cannot be reduction}} expected-error 3 {{'operator+' is a private member 
of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(min : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp for reduction(min : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(max : qa[1]) // expected-error 2 {{expected variable 
name}}
+#pragma omp for reduction(max : qa[1])
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(+ : ba) // expected-error {{a reduction variable 
with array type 'const S2 [5]'}}
+#pragma omp for reduction(+ : ba) // expected-error {{a reduction list item 
with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(* : ca) // expected-error {{a reduction variable 
with array type 'const S3 [5]'}}
+#pragma omp for reduction(* : ca) // expected-error {{a reduction list item 
with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(- : da) // expected-error {{a reduction variable 
with array type 'const int [5]'}} expected-error {{a reduction variable with 
array type 'const float [5]'}}
+#pragma omp for reduction(- : da) // expected-error {{a reduction list item 
with array type 'const int [5]'}} expected-error {{a reduction list item with 
array type 'const float [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -160,7 +160,7 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(&& : S2::S2sc) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp for reduction(&& : S2::S2sc) // expected-error {{const-qualified 
list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -184,7 +184,7 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(+ : r) // expected-error 2 {{const-qualified 
variable cannot be reduction}}
+#pragma omp for reduction(+ : r) // expected-error 2 {{const-qualified list 
item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)
@@ -277,27 +277,27 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(+ : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{const-qualified 
variable cannot be reduction}} expected-error {{'operator+' is a private member 
of 'S2'}}
+#pragma omp for reduction(+ : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 2 {{const-qualified list 
item cannot be reduction}} expected-error {{'operator+' is a private member of 
'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(min : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp for reduction(min : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(max : argv[1]) // expected-error {{expected variable 
name}}
+#pragma omp for reduction(max : argv[1])
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(+ : ba) // expected-error {{a reduction variable 
with array type 'const S2 [5]'}}
+#pragma omp for reduction(+ : ba) // expected-error {{a reduction list item 
with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(* : ca) // expected-error {{a reduction variable 
with array type 'const S3 [5]'}}
+#pragma omp for reduction(* : ca) // expected-error {{a reduction list item 
with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(- : da) // expected-error {{a reduction variable 
with array type 'const int [5]'}}
+#pragma omp for reduction(- : da) // expected-error {{a reduction list item 
with array type 'const int [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -309,7 +309,7 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(&& : S2::S2sc) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp for reduction(&& : S2::S2sc) // expected-error {{const-qualified 
list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -341,7 +341,7 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for reduction(+ : r) // expected-error {{const-qualified variable 
cannot be reduction}}
+#pragma omp for reduction(+ : r) // expected-error {{const-qualified list item 
cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)

Modified: cfe/trunk/test/OpenMP/for_simd_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/for_simd_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/for_simd_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/for_simd_reduction_messages.cpp Wed Sep 30 04:22:36 
2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -112,7 +113,7 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name}}
+#pragma omp for simd reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -128,27 +129,27 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 3 
{{const-qualified variable cannot be reduction}} expected-error 3 {{'operator+' 
is a private member of 'S2'}}
+#pragma omp for simd reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 3 
{{const-qualified list item cannot be reduction}} expected-error 3 
{{'operator+' is a private member of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp for simd reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(max : qa[1]) // expected-error 2 {{expected 
variable name}}
+#pragma omp for simd reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp for simd reduction(+ : ba) // expected-error {{a reduction list 
item with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp for simd reduction(* : ca) // expected-error {{a reduction list 
item with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}} expected-error {{a reduction 
variable with array type 'const float [5]'}}
+#pragma omp for simd reduction(- : da) // expected-error {{a reduction list 
item with array type 'const int [5]'}} expected-error {{a reduction list item 
with array type 'const float [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -160,7 +161,7 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -184,7 +185,7 @@ T tmain(T argc) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(+ : r) // expected-error 2 {{const-qualified 
variable cannot be reduction}}
+#pragma omp for simd reduction(+ : r) // expected-error 2 {{const-qualified 
list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)
@@ -261,7 +262,7 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -277,27 +278,27 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 
{{const-qualified variable cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
+#pragma omp for simd reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 
{{const-qualified list item cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp for simd reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(max : argv[1]) // expected-error {{expected 
variable name}}
+#pragma omp for simd reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp for simd reduction(+ : ba) // expected-error {{a reduction list 
item with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp for simd reduction(* : ca) // expected-error {{a reduction list 
item with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}}
+#pragma omp for simd reduction(- : da) // expected-error {{a reduction list 
item with array type 'const int [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -309,7 +310,7 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
@@ -337,7 +338,7 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel
-#pragma omp for simd reduction(+ : r) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp for simd reduction(+ : r) // expected-error {{const-qualified list 
item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)

Modified: cfe/trunk/test/OpenMP/parallel_ast_print.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/parallel_ast_print.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/parallel_ast_print.cpp (original)
+++ cfe/trunk/test/OpenMP/parallel_ast_print.cpp Wed Sep 30 04:22:36 2015
@@ -33,11 +33,12 @@ T tmain(T argc, T *argv) {
   T b = argc, c, d, e, f, g;
   static T a;
   S<T> s;
+  T arr[C][10], arr1[C];
 #pragma omp parallel
   a=2;
-#pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared 
(d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS) proc_bind(master) 
reduction(+:c) reduction(max:e)
+#pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared 
(d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS) proc_bind(master) 
reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10])
   foo();
-#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f) 
reduction(&& : g)
+#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f, 
arr[0:C][:argc]) reduction(&& : g)
   foo();
   return 0;
 }
@@ -46,31 +47,34 @@ T tmain(T argc, T *argv) {
 // CHECK-NEXT: int b = argc, c, d, e, f, g;
 // CHECK-NEXT: static int a;
 // CHECK-NEXT: S<int> s;
+// CHECK-NEXT: int arr[5][10], arr1[5];
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: a = 2;
-// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) 
copyin(S<int>::TS) proc_bind(master) reduction(+: c) reduction(max: e)
+// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) 
copyin(S<int>::TS) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: 
e,arr[:5][0:10])
 // CHECK-NEXT: foo()
-// CHECK-NEXT: #pragma omp parallel if(5) num_threads(s) proc_bind(close) 
reduction(^: e,f) reduction(&&: g)
+// CHECK-NEXT: #pragma omp parallel if(5) num_threads(s) proc_bind(close) 
reduction(^: e,f,arr[0:5][:argc]) reduction(&&: g)
 // CHECK-NEXT: foo()
 // CHECK: template <typename T = long, int C = 1> long tmain(long argc, long 
*argv) {
 // CHECK-NEXT: long b = argc, c, d, e, f, g;
 // CHECK-NEXT: static long a;
 // CHECK-NEXT: S<long> s;
+// CHECK-NEXT: long arr[1][10], arr1[1];
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: a = 2;
-// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) 
copyin(S<long>::TS) proc_bind(master) reduction(+: c) reduction(max: e)
+// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) 
copyin(S<long>::TS) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: 
e,arr[:1][0:10])
 // CHECK-NEXT: foo()
-// CHECK-NEXT: #pragma omp parallel if(1) num_threads(s) proc_bind(close) 
reduction(^: e,f) reduction(&&: g)
+// CHECK-NEXT: #pragma omp parallel if(1) num_threads(s) proc_bind(close) 
reduction(^: e,f,arr[0:1][:argc]) reduction(&&: g)
 // CHECK-NEXT: foo()
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T a;
 // CHECK-NEXT: S<T> s;
+// CHECK-NEXT: T arr[C][10], arr1[C];
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: a = 2;
-// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) 
copyin(S<T>::TS) proc_bind(master) reduction(+: c) reduction(max: e)
+// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) 
copyin(S<T>::TS) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: 
e,arr[:C][0:10])
 // CHECK-NEXT: foo()
-// CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) 
reduction(^: e,f) reduction(&&: g)
+// CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) 
reduction(^: e,f,arr[0:C][:argc]) reduction(&&: g)
 // CHECK-NEXT: foo()
 
 enum Enum { };
@@ -80,19 +84,20 @@ int main (int argc, char **argv) {
   int b = argc, c, d, e, f, g;
   static int a;
   #pragma omp threadprivate(a)
+  int arr[10][argc], arr1[2];
   Enum ee;
 // CHECK: Enum ee;
 #pragma omp parallel
 // CHECK-NEXT: #pragma omp parallel
   a=2;
 // CHECK-NEXT: a = 2;
-#pragma omp parallel default(none), private(argc,b) firstprivate(argv) if 
(parallel: argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(| : 
c, d) reduction(* : e)
-// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) if(parallel: argc > 0) num_threads(ee) copyin(a) 
proc_bind(spread) reduction(|: c,d) reduction(*: e)
+#pragma omp parallel default(none), private(argc,b) firstprivate(argv) if 
(parallel: argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(| : 
c, d, arr1[argc]) reduction(* : e, arr[:10][0:argc])
+// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) 
firstprivate(argv) if(parallel: argc > 0) num_threads(ee) copyin(a) 
proc_bind(spread) reduction(|: c,d,arr1[argc]) reduction(*: e,arr[:10][0:argc])
   foo();
 // CHECK-NEXT: foo();
-// CHECK-NEXT: #pragma omp parallel if(b) num_threads(c) proc_bind(close) 
reduction(^: e,f) reduction(&&: g)
+// CHECK-NEXT: #pragma omp parallel if(b) num_threads(c) proc_bind(close) 
reduction(^: e,f) reduction(&&: g,arr[0:argc][:10])
 // CHECK-NEXT: foo()
-#pragma omp parallel if (b) num_threads(c) proc_bind(close) reduction(^:e, f) 
reduction(&& : g)
+#pragma omp parallel if (b) num_threads(c) proc_bind(close) reduction(^:e, f) 
reduction(&& : g, arr[0:argc][:10])
   foo();
   return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x);
 }

Modified: cfe/trunk/test/OpenMP/parallel_for_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/parallel_for_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/parallel_for_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/parallel_for_reduction_messages.cpp Wed Sep 30 
04:22:36 2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -102,7 +103,7 @@ T tmain(T argc) {
 #pragma omp parallel for reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this 
'('}} expected-error {{invalid operands to binary expression ('float' and 
'float')}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name}}
+#pragma omp parallel for reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for reduction(foo : argc) //expected-error {{incorrect 
reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 
'min' or 'max'}}
@@ -114,22 +115,22 @@ T tmain(T argc) {
 #pragma omp parallel for reduction(^ : T) // expected-error {{'T' does not 
refer to a value}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 3 
{{const-qualified variable cannot be reduction}} expected-error 3 {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel for reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 3 
{{const-qualified list item cannot be reduction}} expected-error 3 
{{'operator+' is a private member of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel for reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(max : qa[1]) // expected-error 2 {{expected 
variable name}}
+#pragma omp parallel for reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp parallel for reduction(+ : ba) // expected-error {{a reduction 
list item with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp parallel for reduction(* : ca) // expected-error {{a reduction 
list item with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}} expected-error {{a reduction 
variable with array type 'const float [5]'}}
+#pragma omp parallel for reduction(- : da) // expected-error {{a reduction 
list item with array type 'const int [5]'}} expected-error {{a reduction list 
item with array type 'const float [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for reduction(^ : fl) // expected-error {{invalid 
operands to binary expression ('float' and 'float')}}
@@ -138,7 +139,7 @@ T tmain(T argc) {
 #pragma omp parallel for reduction(&& : S2::S2s)
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for reduction(+ : h, k) // expected-error {{threadprivate 
or thread local variable cannot be reduction}}
@@ -157,7 +158,7 @@ T tmain(T argc) {
 #pragma omp parallel for reduction(+ : p), reduction(+ : p) // expected-error 
3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 
3 {{previously referenced here}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(+ : r) // expected-error 2 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for reduction(+ : r) // expected-error 2 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)
@@ -224,7 +225,7 @@ int main(int argc, char **argv) {
 #pragma omp parallel for reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp parallel for reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for reduction(~ : argc) // expected-error {{expected 
unqualified-id}}
@@ -236,22 +237,22 @@ int main(int argc, char **argv) {
 #pragma omp parallel for reduction(^ : S1) // expected-error {{'S1' does not 
refer to a value}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 
{{const-qualified variable cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel for reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 
{{const-qualified list item cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel for reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(max : argv[1]) // expected-error {{expected 
variable name}}
+#pragma omp parallel for reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp parallel for reduction(+ : ba) // expected-error {{a reduction 
list item with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp parallel for reduction(* : ca) // expected-error {{a reduction 
list item with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}}
+#pragma omp parallel for reduction(- : da) // expected-error {{a reduction 
list item with array type 'const int [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for reduction(^ : fl) // expected-error {{invalid 
operands to binary expression ('float' and 'float')}}
@@ -260,7 +261,7 @@ int main(int argc, char **argv) {
 #pragma omp parallel for reduction(&& : S2::S2s)
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for reduction(& : e, g) // expected-error {{calling a 
private constructor of class 'S4'}} expected-error {{invalid operands to binary 
expression ('S4' and 'S4')}} expected-error {{calling a private constructor of 
class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 
'S5')}}
@@ -282,7 +283,7 @@ int main(int argc, char **argv) {
 #pragma omp parallel for reduction(+ : p), reduction(+ : p) // expected-error 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 
{{previously referenced here}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for reduction(+ : r) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp parallel for reduction(+ : r) // expected-error {{const-qualified 
list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)

Modified: cfe/trunk/test/OpenMP/parallel_for_simd_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/parallel_for_simd_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/parallel_for_simd_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/parallel_for_simd_reduction_messages.cpp Wed Sep 30 
04:22:36 2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -102,7 +103,7 @@ T tmain(T argc) {
 #pragma omp parallel for simd reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this 
'('}} expected-error {{invalid operands to binary expression ('float' and 
'float')}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(|| : argc ? i : argc) // 
expected-error 2 {{expected variable name}}
+#pragma omp parallel for simd reduction(|| : argc ? i : argc) // 
expected-error 2 {{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for simd reduction(foo : argc) //expected-error 
{{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', 
'&&', '||', 'min' or 'max'}}
@@ -114,22 +115,22 @@ T tmain(T argc) {
 #pragma omp parallel for simd reduction(^ : T) // expected-error {{'T' does 
not refer to a value}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 3 
{{const-qualified variable cannot be reduction}} expected-error 3 {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel for simd reduction(+ : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 3 
{{const-qualified list item cannot be reduction}} expected-error 3 
{{'operator+' is a private member of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel for simd reduction(min : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 2 
{{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of 
arithmetic type}} expected-error 3 {{const-qualified list item cannot be 
reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(max : qa[1]) // expected-error 2 
{{expected variable name}}
+#pragma omp parallel for simd reduction(max : h.b) // expected-error 
{{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(+ : ba) // expected-error {{a 
reduction variable with array type 'const S2 [5]'}}
+#pragma omp parallel for simd reduction(+ : ba) // expected-error {{a 
reduction list item with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(* : ca) // expected-error {{a 
reduction variable with array type 'const S3 [5]'}}
+#pragma omp parallel for simd reduction(* : ca) // expected-error {{a 
reduction list item with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(- : da) // expected-error {{a 
reduction variable with array type 'const int [5]'}} expected-error {{a 
reduction variable with array type 'const float [5]'}}
+#pragma omp parallel for simd reduction(- : da) // expected-error {{a 
reduction list item with array type 'const int [5]'}} expected-error {{a 
reduction list item with array type 'const float [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for simd reduction(^ : fl) // expected-error {{invalid 
operands to binary expression ('float' and 'float')}}
@@ -138,7 +139,7 @@ T tmain(T argc) {
 #pragma omp parallel for simd reduction(&& : S2::S2s)
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for simd reduction(+ : h, k) // expected-error 
{{threadprivate or thread local variable cannot be reduction}}
@@ -157,7 +158,7 @@ T tmain(T argc) {
 #pragma omp parallel for simd reduction(+ : p), reduction(+ : p) // 
expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} 
expected-note 3 {{previously referenced here}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(+ : r) // expected-error 2 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for simd reduction(+ : r) // expected-error 2 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)
@@ -224,7 +225,7 @@ int main(int argc, char **argv) {
 #pragma omp parallel for simd reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp parallel for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for simd reduction(~ : argc) // expected-error {{expected 
unqualified-id}}
@@ -236,22 +237,22 @@ int main(int argc, char **argv) {
 #pragma omp parallel for simd reduction(^ : S1) // expected-error {{'S1' does 
not refer to a value}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 
{{const-qualified variable cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel for simd reduction(+ : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 2 
{{const-qualified list item cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel for simd reduction(min : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 2 
{{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of 
arithmetic type}} expected-error 2 {{const-qualified list item cannot be 
reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(max : argv[1]) // expected-error 
{{expected variable name}}
+#pragma omp parallel for simd reduction(max : h.b) // expected-error 
{{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(+ : ba) // expected-error {{a 
reduction variable with array type 'const S2 [5]'}}
+#pragma omp parallel for simd reduction(+ : ba) // expected-error {{a 
reduction list item with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(* : ca) // expected-error {{a 
reduction variable with array type 'const S3 [5]'}}
+#pragma omp parallel for simd reduction(* : ca) // expected-error {{a 
reduction list item with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(- : da) // expected-error {{a 
reduction variable with array type 'const int [5]'}}
+#pragma omp parallel for simd reduction(- : da) // expected-error {{a 
reduction list item with array type 'const int [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for simd reduction(^ : fl) // expected-error {{invalid 
operands to binary expression ('float' and 'float')}}
@@ -260,7 +261,7 @@ int main(int argc, char **argv) {
 #pragma omp parallel for simd reduction(&& : S2::S2s)
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for simd reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel for simd reduction(& : e, g) // expected-error {{calling 
a private constructor of class 'S4'}} expected-error {{invalid operands to 
binary expression ('S4' and 'S4')}} expected-error {{calling a private 
constructor of class 'S5'}} expected-error {{invalid operands to binary 
expression ('S5' and 'S5')}}
@@ -282,7 +283,7 @@ int main(int argc, char **argv) {
 #pragma omp parallel for simd reduction(+ : p), reduction(+ : p) // 
expected-error {{variable can appear only once in OpenMP 'reduction' clause}} 
expected-note {{previously referenced here}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp parallel for simd reduction(+ : r) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel for simd reduction(+ : r) // expected-error 
{{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)

Modified: cfe/trunk/test/OpenMP/parallel_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/parallel_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/parallel_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/parallel_reduction_messages.cpp Wed Sep 30 04:22:36 
2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -93,7 +94,7 @@ T tmain(T argc) {
   foo();
 #pragma omp parallel reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this 
'('}} expected-error {{invalid operands to binary expression ('float' and 
'float')}}
   foo();
-#pragma omp parallel reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name}}
+#pragma omp parallel reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name, array element or array section}}
   foo();
 #pragma omp parallel reduction(foo : argc) //expected-error {{incorrect 
reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 
'min' or 'max'}}
   foo();
@@ -101,23 +102,23 @@ T tmain(T argc) {
   foo();
 #pragma omp parallel reduction(^ : T) // expected-error {{'T' does not refer 
to a value}}
   foo();
-#pragma omp parallel reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 3 
{{const-qualified variable cannot be reduction}} expected-error 3 {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 3 
{{const-qualified list item cannot be reduction}} expected-error 3 
{{'operator+' is a private member of 'S2'}}
   foo();
-#pragma omp parallel reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   foo();
-#pragma omp parallel reduction(max : qa[1]) // expected-error 2 {{expected 
variable name}}
+#pragma omp parallel reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   foo();
-#pragma omp parallel reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp parallel reduction(+ : ba) // expected-error {{a reduction list 
item with array type 'const S2 [5]'}}
   foo();
-#pragma omp parallel reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp parallel reduction(* : ca) // expected-error {{a reduction list 
item with array type 'const S3 [5]'}}
   foo();
-#pragma omp parallel reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}} expected-error {{a reduction 
variable with array type 'const float [5]'}}
+#pragma omp parallel reduction(- : da) // expected-error {{a reduction list 
item with array type 'const int [5]'}} expected-error {{a reduction list item 
with array type 'const float [5]'}}
   foo();
 #pragma omp parallel reduction(^ : fl) // expected-error {{invalid operands to 
binary expression ('float' and 'float')}}
   foo();
 #pragma omp parallel reduction(&& : S2::S2s)
   foo();
-#pragma omp parallel reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   foo();
 #pragma omp parallel reduction(+ : h, k) // expected-error {{threadprivate or 
thread local variable cannot be reduction}}
   foo();
@@ -130,7 +131,7 @@ T tmain(T argc) {
   foo();
 #pragma omp parallel reduction(+ : p), reduction(+ : p) // expected-error 3 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 
{{previously referenced here}}
   foo();
-#pragma omp parallel reduction(+ : r) // expected-error 2 {{const-qualified 
variable cannot be reduction}}
+#pragma omp parallel reduction(+ : r) // expected-error 2 {{const-qualified 
list item cannot be reduction}}
   foo();
 #pragma omp parallel shared(i)
 #pragma omp parallel reduction(min : i)
@@ -188,7 +189,7 @@ int main(int argc, char **argv) {
   foo();
 #pragma omp parallel reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   foo();
-#pragma omp parallel reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp parallel reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   foo();
 #pragma omp parallel reduction(~ : argc) // expected-error {{expected 
unqualified-id}}
   foo();
@@ -196,23 +197,23 @@ int main(int argc, char **argv) {
   foo();
 #pragma omp parallel reduction(^ : S1) // expected-error {{'S1' does not refer 
to a value}}
   foo();
-#pragma omp parallel reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 
{{const-qualified variable cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 
{{const-qualified list item cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
   foo();
-#pragma omp parallel reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   foo();
-#pragma omp parallel reduction(max : argv[1]) // expected-error {{expected 
variable name}}
+#pragma omp parallel reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   foo();
-#pragma omp parallel reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp parallel reduction(+ : ba) // expected-error {{a reduction list 
item with array type 'const S2 [5]'}}
   foo();
-#pragma omp parallel reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp parallel reduction(* : ca) // expected-error {{a reduction list 
item with array type 'const S3 [5]'}}
   foo();
-#pragma omp parallel reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}}
+#pragma omp parallel reduction(- : da) // expected-error {{a reduction list 
item with array type 'const int [5]'}}
   foo();
 #pragma omp parallel reduction(^ : fl) // expected-error {{invalid operands to 
binary expression ('float' and 'float')}}
   foo();
 #pragma omp parallel reduction(&& : S2::S2s)
   foo();
-#pragma omp parallel reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   foo();
 #pragma omp parallel reduction(& : e, g) // expected-error {{calling a private 
constructor of class 'S4'}} expected-error {{nvalid operands to binary 
expression ('S4' and 'S4')}} expected-error {{calling a private constructor of 
class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 
'S5')}}
   foo();
@@ -227,7 +228,7 @@ int main(int argc, char **argv) {
   foo();
 #pragma omp parallel reduction(+ : p), reduction(+ : p) // expected-error 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 
{{previously referenced here}}
   foo();
-#pragma omp parallel reduction(+ : r) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp parallel reduction(+ : r) // expected-error {{const-qualified list 
item cannot be reduction}}
   foo();
 #pragma omp parallel shared(i)
 #pragma omp parallel reduction(min : i)

Modified: cfe/trunk/test/OpenMP/parallel_sections_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/parallel_sections_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/parallel_sections_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/parallel_sections_reduction_messages.cpp Wed Sep 30 
04:22:36 2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -111,7 +112,7 @@ T tmain(T argc) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(|| : argc ? i : argc) // 
expected-error 2 {{expected variable name}}
+#pragma omp parallel sections reduction(|| : argc ? i : argc) // 
expected-error 2 {{expected variable name, array element or array section}}
   {
     foo();
   }
@@ -127,27 +128,27 @@ T tmain(T argc) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 3 
{{const-qualified variable cannot be reduction}} expected-error 3 {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel sections reduction(+ : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 3 
{{const-qualified list item cannot be reduction}} expected-error 3 
{{'operator+' is a private member of 'S2'}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel sections reduction(min : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 2 
{{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of 
arithmetic type}} expected-error 3 {{const-qualified list item cannot be 
reduction}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(max : qa[1]) // expected-error 2 
{{expected variable name}}
+#pragma omp parallel sections reduction(max : h.b) // expected-error 
{{expected variable name, array element or array section}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(+ : ba) // expected-error {{a 
reduction variable with array type 'const S2 [5]'}}
+#pragma omp parallel sections reduction(+ : ba) // expected-error {{a 
reduction list item with array type 'const S2 [5]'}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(* : ca) // expected-error {{a 
reduction variable with array type 'const S3 [5]'}}
+#pragma omp parallel sections reduction(* : ca) // expected-error {{a 
reduction list item with array type 'const S3 [5]'}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(- : da) // expected-error {{a 
reduction variable with array type 'const int [5]'}} expected-error {{a 
reduction variable with array type 'const float [5]'}}
+#pragma omp parallel sections reduction(- : da) // expected-error {{a 
reduction list item with array type 'const int [5]'}} expected-error {{a 
reduction list item with array type 'const float [5]'}}
   {
     foo();
   }
@@ -159,7 +160,7 @@ T tmain(T argc) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   {
     foo();
   }
@@ -184,7 +185,7 @@ T tmain(T argc) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(+ : r) // expected-error 2 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel sections reduction(+ : r) // expected-error 2 
{{const-qualified list item cannot be reduction}}
   {
     foo();
   }
@@ -264,7 +265,7 @@ int main(int argc, char **argv) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp parallel sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   {
     foo();
   }
@@ -280,27 +281,27 @@ int main(int argc, char **argv) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 
{{const-qualified variable cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
+#pragma omp parallel sections reduction(+ : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 2 
{{const-qualified list item cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp parallel sections reduction(min : a, b, c, d, f) // expected-error 
{{a reduction list item with incomplete type 'S1'}} expected-error 2 
{{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of 
arithmetic type}} expected-error 2 {{const-qualified list item cannot be 
reduction}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(max : argv[1]) // expected-error 
{{expected variable name}}
+#pragma omp parallel sections reduction(max : h.b) // expected-error 
{{expected variable name, array element or array section}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(+ : ba) // expected-error {{a 
reduction variable with array type 'const S2 [5]'}}
+#pragma omp parallel sections reduction(+ : ba) // expected-error {{a 
reduction list item with array type 'const S2 [5]'}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(* : ca) // expected-error {{a 
reduction variable with array type 'const S3 [5]'}}
+#pragma omp parallel sections reduction(* : ca) // expected-error {{a 
reduction list item with array type 'const S3 [5]'}}
   {
     foo();
   }
-#pragma omp parallel sections reduction(- : da) // expected-error {{a 
reduction variable with array type 'const int [5]'}}
+#pragma omp parallel sections reduction(- : da) // expected-error {{a 
reduction list item with array type 'const int [5]'}}
   {
     foo();
   }
@@ -312,7 +313,7 @@ int main(int argc, char **argv) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   {
     foo();
   }
@@ -341,7 +342,7 @@ int main(int argc, char **argv) {
   {
     foo();
   }
-#pragma omp parallel sections reduction(+ : r) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp parallel sections reduction(+ : r) // expected-error 
{{const-qualified list item cannot be reduction}}
   {
     foo();
   }

Modified: cfe/trunk/test/OpenMP/sections_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/sections_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/sections_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/sections_reduction_messages.cpp Wed Sep 30 04:22:36 
2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -121,7 +122,7 @@ T tmain(T argc) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name}}
+#pragma omp sections reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name, array element or array section}}
   {
     foo();
   }
@@ -141,32 +142,32 @@ T tmain(T argc) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 3 
{{const-qualified variable cannot be reduction}} expected-error 3 {{'operator+' 
is a private member of 'S2'}}
+#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 3 
{{const-qualified list item cannot be reduction}} expected-error 3 
{{'operator+' is a private member of 'S2'}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(max : qa[1]) // expected-error 2 {{expected 
variable name}}
+#pragma omp sections reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp sections reduction(+ : ba) // expected-error {{a reduction list 
item with array type 'const S2 [5]'}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp sections reduction(* : ca) // expected-error {{a reduction list 
item with array type 'const S3 [5]'}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}} expected-error {{a reduction 
variable with array type 'const float [5]'}}
+#pragma omp sections reduction(- : da) // expected-error {{a reduction list 
item with array type 'const int [5]'}} expected-error {{a reduction list item 
with array type 'const float [5]'}}
   {
     foo();
   }
@@ -181,7 +182,7 @@ T tmain(T argc) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   {
     foo();
   }
@@ -211,7 +212,7 @@ T tmain(T argc) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(+ : r) // expected-error 2 {{const-qualified 
variable cannot be reduction}}
+#pragma omp sections reduction(+ : r) // expected-error 2 {{const-qualified 
list item cannot be reduction}}
   {
     foo();
   }
@@ -301,7 +302,7 @@ int main(int argc, char **argv) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   {
     foo();
   }
@@ -321,32 +322,32 @@ int main(int argc, char **argv) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 
{{const-qualified variable cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
+#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 
{{const-qualified list item cannot be reduction}} expected-error {{'operator+' 
is a private member of 'S2'}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(min : a, b, c, d, f) // expected-error 
{{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments 
of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(max : argv[1]) // expected-error {{expected 
variable name}}
+#pragma omp sections reduction(max : h.b) // expected-error {{expected 
variable name, array element or array section}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(+ : ba) // expected-error {{a reduction 
variable with array type 'const S2 [5]'}}
+#pragma omp sections reduction(+ : ba) // expected-error {{a reduction list 
item with array type 'const S2 [5]'}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(* : ca) // expected-error {{a reduction 
variable with array type 'const S3 [5]'}}
+#pragma omp sections reduction(* : ca) // expected-error {{a reduction list 
item with array type 'const S3 [5]'}}
   {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(- : da) // expected-error {{a reduction 
variable with array type 'const int [5]'}}
+#pragma omp sections reduction(- : da) // expected-error {{a reduction list 
item with array type 'const int [5]'}}
   {
     foo();
   }
@@ -361,7 +362,7 @@ int main(int argc, char **argv) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified variable cannot be reduction}}
+#pragma omp sections reduction(&& : S2::S2sc) // expected-error 
{{const-qualified list item cannot be reduction}}
   {
     foo();
   }
@@ -396,7 +397,7 @@ int main(int argc, char **argv) {
     foo();
   }
 #pragma omp parallel
-#pragma omp sections reduction(+ : r) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp sections reduction(+ : r) // expected-error {{const-qualified list 
item cannot be reduction}}
   {
     foo();
   }

Modified: cfe/trunk/test/OpenMP/simd_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/simd_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/simd_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/simd_reduction_messages.cpp Wed Sep 30 04:22:36 2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -102,7 +103,7 @@ T tmain(T argc) {
 #pragma omp simd reduction(| : argc, // expected-error {{expected expression}} 
expected-error {{expected ')'}} expected-note {{to match this '('}} 
expected-error {{invalid operands to binary expression ('float' and 'float')}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name}}
+#pragma omp simd reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp simd reduction(foo : argc) //expected-error {{incorrect reduction 
identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 
'max'}}
@@ -114,22 +115,22 @@ T tmain(T argc) {
 #pragma omp simd reduction(^ : T) // expected-error {{'T' does not refer to a 
value}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(+ : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 3 {{const-qualified 
variable cannot be reduction}} expected-error 3 {{'operator+' is a private 
member of 'S2'}}
+#pragma omp simd reduction(+ : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 3 {{const-qualified list 
item cannot be reduction}} expected-error 3 {{'operator+' is a private member 
of 'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(min : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp simd reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(max : qa[1]) // expected-error 2 {{expected 
variable name}}
+#pragma omp simd reduction(max : h.b) // expected-error {{expected variable 
name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(+ : ba) // expected-error {{a reduction variable 
with array type 'const S2 [5]'}}
+#pragma omp simd reduction(+ : ba) // expected-error {{a reduction list item 
with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(* : ca) // expected-error {{a reduction variable 
with array type 'const S3 [5]'}}
+#pragma omp simd reduction(* : ca) // expected-error {{a reduction list item 
with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(- : da) // expected-error {{a reduction variable 
with array type 'const int [5]'}} expected-error {{a reduction variable with 
array type 'const float [5]'}}
+#pragma omp simd reduction(- : da) // expected-error {{a reduction list item 
with array type 'const int [5]'}} expected-error {{a reduction list item with 
array type 'const float [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp simd reduction(^ : fl) // expected-error {{invalid operands to 
binary expression ('float' and 'float')}}
@@ -138,7 +139,7 @@ T tmain(T argc) {
 #pragma omp simd reduction(&& : S2::S2s) // expected-error {{shared variable 
cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(&& : S2::S2sc) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp simd reduction(&& : S2::S2sc) // expected-error {{const-qualified 
list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp simd reduction(+ : h, k) // expected-error {{threadprivate or 
thread local variable cannot be reduction}}
@@ -160,7 +161,7 @@ T tmain(T argc) {
 #pragma omp simd reduction(+ : p), reduction(+ : p) // expected-error 3 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 
{{previously referenced here}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(+ : r) // expected-error 2 {{const-qualified 
variable cannot be reduction}}
+#pragma omp simd reduction(+ : r) // expected-error 2 {{const-qualified list 
item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)
@@ -227,7 +228,7 @@ int main(int argc, char **argv) {
 #pragma omp simd reduction(| : argc, // expected-error {{expected expression}} 
expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp simd reduction(~ : argc) // expected-error {{expected 
unqualified-id}}
@@ -239,22 +240,22 @@ int main(int argc, char **argv) {
 #pragma omp simd reduction(^ : S1) // expected-error {{'S1' does not refer to 
a value}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(+ : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{const-qualified 
variable cannot be reduction}} expected-error {{'operator+' is a private member 
of 'S2'}}
+#pragma omp simd reduction(+ : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 2 {{const-qualified list 
item cannot be reduction}} expected-error {{'operator+' is a private member of 
'S2'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(min : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp simd reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(max : argv[1]) // expected-error {{expected 
variable name}}
+#pragma omp simd reduction(max : h.b) // expected-error {{expected variable 
name, array element or array section}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(+ : ba) // expected-error {{a reduction variable 
with array type 'const S2 [5]'}}
+#pragma omp simd reduction(+ : ba) // expected-error {{a reduction list item 
with array type 'const S2 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(* : ca) // expected-error {{a reduction variable 
with array type 'const S3 [5]'}}
+#pragma omp simd reduction(* : ca) // expected-error {{a reduction list item 
with array type 'const S3 [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(- : da) // expected-error {{a reduction variable 
with array type 'const int [5]'}}
+#pragma omp simd reduction(- : da) // expected-error {{a reduction list item 
with array type 'const int [5]'}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp simd reduction(^ : fl) // expected-error {{invalid operands to 
binary expression ('float' and 'float')}}
@@ -263,7 +264,7 @@ int main(int argc, char **argv) {
 #pragma omp simd reduction(&& : S2::S2s) // expected-error {{shared variable 
cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(&& : S2::S2sc) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp simd reduction(&& : S2::S2sc) // expected-error {{const-qualified 
list item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp simd reduction(& : e, g) // expected-error {{calling a private 
constructor of class 'S4'}} expected-error {{invalid operands to binary 
expression ('S4' and 'S4')}} expected-error {{calling a private constructor of 
class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 
'S5')}}
@@ -285,7 +286,7 @@ int main(int argc, char **argv) {
 #pragma omp simd reduction(+ : p), reduction(+ : p) // expected-error 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 
{{previously referenced here}}
   for (int i = 0; i < 10; ++i)
     foo();
-#pragma omp simd reduction(+ : r) // expected-error {{const-qualified variable 
cannot be reduction}}
+#pragma omp simd reduction(+ : r) // expected-error {{const-qualified list 
item cannot be reduction}}
   for (int i = 0; i < 10; ++i)
     foo();
 #pragma omp parallel shared(i)

Modified: cfe/trunk/test/OpenMP/teams_reduction_messages.cpp
URL: 
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/teams_reduction_messages.cpp?rev=248880&r1=248879&r2=248880&view=diff
==============================================================================
--- cfe/trunk/test/OpenMP/teams_reduction_messages.cpp (original)
+++ cfe/trunk/test/OpenMP/teams_reduction_messages.cpp Wed Sep 30 04:22:36 2015
@@ -26,6 +26,7 @@ class S3 {
   int a;
 
 public:
+  int b;
   S3() : a(0) {}
   S3(const S3 &s3) : a(s3.a) {}
   S3 operator+(const S3 &arg1) { return arg1; }
@@ -103,7 +104,7 @@ T tmain(T argc) {
 #pragma omp teams reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this 
'('}} expected-error {{invalid operands to binary expression ('float' and 
'float')}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name}}
+#pragma omp teams reduction(|| : argc ? i : argc) // expected-error 2 
{{expected variable name, array element or array section}}
   foo();
 #pragma omp target
 #pragma omp teams reduction(foo : argc) //expected-error {{incorrect reduction 
identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 
'max'}}
@@ -115,22 +116,22 @@ T tmain(T argc) {
 #pragma omp teams reduction(^ : T) // expected-error {{'T' does not refer to a 
value}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(+ : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 3 {{const-qualified 
variable cannot be reduction}} expected-error 3 {{'operator+' is a private 
member of 'S2'}}
+#pragma omp teams reduction(+ : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 3 {{const-qualified list 
item cannot be reduction}} expected-error 3 {{'operator+' is a private member 
of 'S2'}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(min : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified variable cannot be reduction}}
+#pragma omp teams reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 3 {{const-qualified list item cannot be reduction}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(max : qa[1]) // expected-error 2 {{expected 
variable name}}
+#pragma omp teams reduction(max : h.b) // expected-error {{expected variable 
name, array element or array section}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(+ : ba) // expected-error {{a reduction variable 
with array type 'const S2 [5]'}}
+#pragma omp teams reduction(+ : ba) // expected-error {{a reduction list item 
with array type 'const S2 [5]'}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(* : ca) // expected-error {{a reduction variable 
with array type 'const S3 [5]'}}
+#pragma omp teams reduction(* : ca) // expected-error {{a reduction list item 
with array type 'const S3 [5]'}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(- : da) // expected-error {{a reduction variable 
with array type 'const int [5]'}} expected-error {{a reduction variable with 
array type 'const float [5]'}}
+#pragma omp teams reduction(- : da) // expected-error {{a reduction list item 
with array type 'const int [5]'}} expected-error {{a reduction list item with 
array type 'const float [5]'}}
   foo();
 #pragma omp target
 #pragma omp teams reduction(^ : fl) // expected-error {{invalid operands to 
binary expression ('float' and 'float')}}
@@ -139,7 +140,7 @@ T tmain(T argc) {
 #pragma omp teams reduction(&& : S2::S2s)
   foo();
 #pragma omp target
-#pragma omp teams reduction(&& : S2::S2sc) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp teams reduction(&& : S2::S2sc) // expected-error {{const-qualified 
list item cannot be reduction}}
   foo();
 #pragma omp target
 #pragma omp teams reduction(+ : h, k) // expected-error {{threadprivate or 
thread local variable cannot be reduction}}
@@ -158,7 +159,7 @@ T tmain(T argc) {
 #pragma omp teams reduction(+ : p), reduction(+ : p) // expected-error 3 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 
{{previously referenced here}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(+ : r) // expected-error 2 {{const-qualified 
variable cannot be reduction}}
+#pragma omp teams reduction(+ : r) // expected-error 2 {{const-qualified list 
item cannot be reduction}}
   foo();
 #pragma omp parallel shared(i)
 #pragma omp parallel reduction(min : i)
@@ -231,7 +232,7 @@ int main(int argc, char **argv) {
 #pragma omp teams reduction(| : argc, // expected-error {{expected 
expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name}}
+#pragma omp teams reduction(|| : argc > 0 ? argv[1] : argv[2]) // 
expected-error {{expected variable name, array element or array section}}
   foo();
 #pragma omp target
 #pragma omp teams reduction(~ : argc) // expected-error {{expected 
unqualified-id}}
@@ -243,22 +244,22 @@ int main(int argc, char **argv) {
 #pragma omp teams reduction(^ : S1) // expected-error {{'S1' does not refer to 
a value}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(+ : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{const-qualified 
variable cannot be reduction}} expected-error {{'operator+' is a private member 
of 'S2'}}
+#pragma omp teams reduction(+ : a, b, c, d, f) // expected-error {{a reduction 
list item with incomplete type 'S1'}} expected-error 2 {{const-qualified list 
item cannot be reduction}} expected-error {{'operator+' is a private member of 
'S2'}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(min : a, b, c, d, f) // expected-error {{reduction 
variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP 
clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified variable cannot be reduction}}
+#pragma omp teams reduction(min : a, b, c, d, f) // expected-error {{a 
reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of 
OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} 
expected-error 2 {{const-qualified list item cannot be reduction}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(max : argv[1]) // expected-error {{expected 
variable name}}
+#pragma omp teams reduction(max : h.b) // expected-error {{expected variable 
name, array element or array section}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(+ : ba) // expected-error {{a reduction variable 
with array type 'const S2 [5]'}}
+#pragma omp teams reduction(+ : ba) // expected-error {{a reduction list item 
with array type 'const S2 [5]'}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(* : ca) // expected-error {{a reduction variable 
with array type 'const S3 [5]'}}
+#pragma omp teams reduction(* : ca) // expected-error {{a reduction list item 
with array type 'const S3 [5]'}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(- : da) // expected-error {{a reduction variable 
with array type 'const int [5]'}}
+#pragma omp teams reduction(- : da) // expected-error {{a reduction list item 
with array type 'const int [5]'}}
   foo();
 #pragma omp target
 #pragma omp teams reduction(^ : fl) // expected-error {{invalid operands to 
binary expression ('float' and 'float')}}
@@ -267,7 +268,7 @@ int main(int argc, char **argv) {
 #pragma omp teams reduction(&& : S2::S2s)
   foo();
 #pragma omp target
-#pragma omp teams reduction(&& : S2::S2sc) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp teams reduction(&& : S2::S2sc) // expected-error {{const-qualified 
list item cannot be reduction}}
   foo();
 #pragma omp target
 #pragma omp teams reduction(& : e, g) // expected-error {{calling a private 
constructor of class 'S4'}} expected-error {{invalid operands to binary 
expression ('S4' and 'S4')}} expected-error {{calling a private constructor of 
class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 
'S5')}}
@@ -289,7 +290,7 @@ int main(int argc, char **argv) {
 #pragma omp teams reduction(+ : p), reduction(+ : p) // expected-error 
{{variable can appear only once in OpenMP 'reduction' clause}} expected-note 
{{previously referenced here}}
   foo();
 #pragma omp target
-#pragma omp teams reduction(+ : r) // expected-error {{const-qualified 
variable cannot be reduction}}
+#pragma omp teams reduction(+ : r) // expected-error {{const-qualified list 
item cannot be reduction}}
   foo();
 #pragma omp parallel shared(i)
 #pragma omp parallel reduction(min : i)


_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits