[OPENMP]Add support for analysis of linear variables and step.

[ABataev]

Summary

Added support for basic analysis of the linear variables and linear step
expression. Linear loop iteration variables must be excluded from this
analysis, only non-loop iteration variables must be analyzed.

[ABataev]

Rebase

[NoQ]

Thx again!

lib/AST/OpenMPClause.cpp

473

Formatting error ^.^

477

This function name almost makes me slightly uncomfortable -___-"

test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp

9

I see you guys don't do the // no-warning thing very often? 'Cause even if it's meaningless for VerifyDiagnosticsConsumer, i find it pretty useful when reading other people's tests and trying to figure out what they were about. I.e., if somebody accidentally breaks your machinery and they see a warning on this test, it would be nice if they immediately understand that this is a false positive and they need to go fix their code rather than add an // expected-warning.

include/clang/AST/OpenMPClause.h

class OMPLinearClause final
   /// Sets the list of final update expressions for linear variables.
   MutableArrayRef<Expr *> getFinals() {
     return MutableArrayRef<Expr *>(getUpdates().end(), varlist_size());
   }
   ArrayRef<const Expr *> getFinals() const {
     return llvm::makeArrayRef(getUpdates().end(), varlist_size());
   }
 
+  /// Gets the list of used expressions for linear variables.
+  MutableArrayRef<Expr *> getUsedExprs() {
+    return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1);
+  }
+  ArrayRef<const Expr *> getUsedExprs() const {
+    return llvm::makeArrayRef(getFinals().end() + 2, varlist_size() + 1);
+  }
+
   /// Sets the list of the copies of original linear variables.
   /// \param PL List of expressions.
   void setPrivates(ArrayRef<Expr *> PL);
 
   /// Sets the list of the initial values for linear variables.
   /// \param IL List of expressions.
   void setInits(ArrayRef<Expr *> IL);
 
public:
   /// Sets the list of update expressions for linear variables.
   /// \param UL List of expressions.
   void setUpdates(ArrayRef<Expr *> UL);
 
   /// Sets the list of final update expressions for linear variables.
   /// \param FL List of expressions.
   void setFinals(ArrayRef<Expr *> FL);
 
+  /// Sets the list of used expressions for the linear clause.
+  void setUsedExprs(ArrayRef<Expr *> UE);
+
   using privates_iterator = MutableArrayRef<Expr *>::iterator;
   using privates_const_iterator = ArrayRef<const Expr *>::iterator;
   using privates_range = llvm::iterator_range<privates_iterator>;
   using privates_const_range = llvm::iterator_range<privates_const_iterator>;
 
   privates_range privates() {
     return privates_range(getPrivates().begin(), getPrivates().end());
   }
public:
   finals_range finals() {
     return finals_range(getFinals().begin(), getFinals().end());
   }
 
   finals_const_range finals() const {
     return finals_const_range(getFinals().begin(), getFinals().end());
   }
 
+  using used_expressions_iterator = MutableArrayRef<Expr *>::iterator;
+  using used_expressions_const_iterator = ArrayRef<const Expr *>::iterator;
+  using used_expressions_range =
+      llvm::iterator_range<used_expressions_iterator>;
+  using used_expressions_const_range =
+      llvm::iterator_range<used_expressions_const_iterator>;
+
+  used_expressions_range used_expressions() {
+    return finals_range(getUsedExprs().begin(), getUsedExprs().end());
+  }
+
+  used_expressions_const_range used_expressions() const {
+    return finals_const_range(getUsedExprs().begin(), getUsedExprs().end());
+  }
+
   child_range children() {
     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
                        reinterpret_cast<Stmt **>(varlist_end()));
   }
 
   const_child_range children() const {
     auto Children = const_cast<OMPLinearClause *>(this)->children();
     return const_child_range(Children.begin(), Children.end());
   }
 
-  child_range used_children() {
-    return child_range(child_iterator(), child_iterator());
-  }
+  child_range used_children();
+
   const_child_range used_children() const {
-    return const_child_range(const_child_iterator(), const_child_iterator());
+    auto Children = const_cast<OMPLinearClause *>(this)->used_children();
+    return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == OMPC_linear;
   }
 };
 
 /// This represents clause 'aligned' in the '#pragma omp ...'

lib/AST/OpenMPClause.cpp

 }
 
 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
   assert(FL.size() == varlist_size() &&
          "Number of final updates is not the same as the preallocated buffer");
   std::copy(FL.begin(), FL.end(), getUpdates().end());
 }
 
+void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
+  assert(
+      UE.size() == varlist_size() + 1 &&
+      "Number of used expressions is not the same as the preallocated buffer");
+  std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
+}
+
 OMPLinearClause *OMPLinearClause::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
     SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
     ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
     Stmt *PreInit, Expr *PostUpdate) {
-  // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
-  // (Step and CalcStep).
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
+  // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
+  // (Step and CalcStep), list of used expression + step.
+  void *Mem =
+      C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
   OMPLinearClause *Clause = new (Mem) OMPLinearClause(
       StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setPrivates(PL);
   Clause->setInits(IL);
   // Fill update and final expressions with zeroes, they are provided later,
   // after the directive construction.
   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
             nullptr);
   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
             nullptr);
+  std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
+            nullptr);
   Clause->setStep(Step);
   Clause->setCalcStep(CalcStep);
   Clause->setPreInitStmt(PreInit);
   Clause->setPostUpdateExpr(PostUpdate);
   return Clause;
 }
 
 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
                                               unsigned NumVars) {
-  // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
-  // (Step and CalcStep).
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
+  // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
+  // (Step and CalcStep), list of used expression + step.
+  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars  +1));
   return new (Mem) OMPLinearClause(NumVars);
 }
 
+OMPClause::child_range OMPLinearClause::used_children() {
+  // Range includes only non-nullptr elements.
+  return child_range(
+      reinterpret_cast<Stmt **>(getUsedExprs().begin()),
+      reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
+}
+
 OMPAlignedClause *
 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation ColonLoc,
                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
   OMPAlignedClause *Clause = new (Mem)
       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);

lib/Sema/SemaOpenMP.cpp

 }
 
 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
                                      Expr *NumIterations, Sema &SemaRef,
                                      Scope *S, DSAStackTy *Stack) {
   // Walk the vars and build update/final expressions for the CodeGen.
   SmallVector<Expr *, 8> Updates;
   SmallVector<Expr *, 8> Finals;
+  SmallVector<Expr *, 8> UsedExprs;
   Expr *Step = Clause.getStep();
   Expr *CalcStep = Clause.getCalcStep();
   // OpenMP [2.14.3.7, linear clause]
   // If linear-step is not specified it is assumed to be 1.
   if (!Step)
     Step = SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get();
   else if (CalcStep)
     Step = cast<BinaryOperator>(CalcStep)->getLHS();
for (Expr *RefExpr : Clause.varlists()) {
     else
       Final = *CurPrivate;
     Final = SemaRef.ActOnFinishFullExpr(Final.get(), DE->getBeginLoc(),
                                         /*DiscardedValue*/ false);
 
     if (!Update.isUsable() || !Final.isUsable()) {
       Updates.push_back(nullptr);
       Finals.push_back(nullptr);
+      UsedExprs.push_back(nullptr);
       HasErrors = true;
     } else {
       Updates.push_back(Update.get());
       Finals.push_back(Final.get());
+      if (!Info.first)
+        UsedExprs.push_back(SimpleRefExpr);
     }
     ++CurInit;
     ++CurPrivate;
   }
+  if (Expr *S = Clause.getStep())
+    UsedExprs.push_back(S);
+  // Fill the remaining part with the nullptr.
+  UsedExprs.append(Clause.varlist_size() + 1 - UsedExprs.size(), nullptr);
   Clause.setUpdates(Updates);
   Clause.setFinals(Finals);
+  Clause.setUsedExprs(UsedExprs);
   return HasErrors;
 }
 
 OMPClause *Sema::ActOnOpenMPAlignedClause(
     ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
     SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
   SmallVector<Expr *, 8> Vars;
   for (Expr *RefExpr : VarList) {

lib/Serialization/ASTReader.cpp

for (unsigned i = 0; i != NumVars; ++i)
     Vars.push_back(Record.readSubExpr());
   C->setUpdates(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
     Vars.push_back(Record.readSubExpr());
   C->setFinals(Vars);
   C->setStep(Record.readSubExpr());
   C->setCalcStep(Record.readSubExpr());
+  Vars.clear();
+  for (unsigned I = 0; I != NumVars + 1; ++I)
+    Vars.push_back(Record.readSubExpr());
+  C->setUsedExprs(Vars);
 }
 
 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
   C->setLParenLoc(Record.readSourceLocation());
   C->setColonLoc(Record.readSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);

lib/Serialization/ASTWriter.cpp

void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
   for (auto *VE : C->updates()) {
     Record.AddStmt(VE);
   }
   for (auto *VE : C->finals()) {
     Record.AddStmt(VE);
   }
   Record.AddStmt(C->getStep());
   Record.AddStmt(C->getCalcStep());
+  for (auto *VE : C->used_expressions())
+    Record.AddStmt(VE);
 }
 
 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {
   Record.push_back(C->varlist_size());
   Record.AddSourceLocation(C->getLParenLoc());
   Record.AddSourceLocation(C->getColonLoc());
   for (auto *VE : C->varlists())
     Record.AddStmt(VE);

test/Analysis/cfg-openmp.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
 
 // CHECK-LABEL:  void xxx(int argc)
 void xxx(int argc) {
 // CHECK:        [B1]
 // CHECK-NEXT:   1: int x;
 // CHECK-NEXT:   2: int cond;
 // CHECK-NEXT:   3: int fp;
 // CHECK-NEXT:   4: int rd;
-  int x, cond, fp, rd;
+// CHECK-NEXT:   5: int lin;
+// CHECK-NEXT:   6: int step;
+  int x, cond, fp, rd, lin, step;
 // CHECK-NEXT:   [[#ATOM:]]: x
 // CHECK-NEXT:   [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   [[#ATOM+2]]: argc
 // CHECK-NEXT:   [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
 // CHECK-NEXT:   [[#ATOM+4]]: #pragma omp atomic read
 // CHECK-NEXT:   [B1.[[#ATOM+3]]];
 #pragma omp atomic read
   argc = x;

 // CHECK-NEXT:        [B1.[[#DS+3]]];
 #pragma omp distribute simd
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#FOR:]]: x
 // CHECK-NEXT:  [[#FOR+1]]: [B1.[[#FOR]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#FOR+2]]: argc
 // CHECK-NEXT:  [[#FOR+3]]: [B1.[[#FOR+2]]] = [B1.[[#FOR+1]]]
-// CHECK-NEXT:  [[#FOR+4]]: #pragma omp for
+// CHECK-NEXT:  [[#FOR+4]]: lin
+// CHECK-NEXT:  [[#FOR+5]]: step
+// CHECK-NEXT:  [[#FOR+6]]: [B1.[[#FOR+5]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#FOR+7]]: #pragma omp for linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#FOR+3]]];
-#pragma omp for
+#pragma omp for linear(lin : step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#FS:]]: x
 // CHECK-NEXT:  [[#FS+1]]: [B1.[[#FS]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#FS+2]]: argc
 // CHECK-NEXT:  [[#FS+3]]: [B1.[[#FS+2]]] = [B1.[[#FS+1]]]
-// CHECK-NEXT:  [[#FS+4]]: #pragma omp for simd
+// CHECK-NEXT:  [[#FS+4]]: lin
+// CHECK-NEXT:  [[#FS+5]]: step
+// CHECK-NEXT:  [[#FS+6]]: [B1.[[#FS+5]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#FS+7]]: #pragma omp for simd linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#FS+3]]];
-#pragma omp for simd
+#pragma omp for simd linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#MASTER:]]: x
 // CHECK-NEXT:  [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#MASTER+2]]: argc
 // CHECK-NEXT:  [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
 // CHECK-NEXT:  [[#MASTER+4]]: #pragma omp master
 // CHECK-NEXT:    [B1.[[#MASTER+3]]];

 // CHECK-NEXT:  [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#PF+2]]: argc
 // CHECK-NEXT:  [[#PF+3]]: [B1.[[#PF+2]]] = [B1.[[#PF+1]]]
 // CHECK-NEXT:  [[#PF+4]]: cond
 // CHECK-NEXT:  [[#PF+5]]: [B1.[[#PF+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#PF+6]]: [B1.[[#PF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#PF+7]]: fp
 // CHECK-NEXT:  [[#PF+8]]: rd
-// CHECK-NEXT:  [[#PF+9]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd)
+// CHECK-NEXT:  [[#PF+9]]: lin
+// CHECK-NEXT:  [[#PF+10]]: step
+// CHECK-NEXT:  [[#PF+11]]: [B1.[[#PF+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#PF+12]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#PF+3]]];
-#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd)
+#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#PFS:]]: x
 // CHECK-NEXT:  [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#PFS+2]]: argc
 // CHECK-NEXT:  [[#PFS+3]]: [B1.[[#PFS+2]]] = [B1.[[#PFS+1]]]
 // CHECK-NEXT:  [[#PFS+4]]: cond
 // CHECK-NEXT:  [[#PFS+5]]: [B1.[[#PFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#PFS+6]]: [B1.[[#PFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#PFS+7]]: fp
 // CHECK-NEXT:  [[#PFS+8]]: rd
-// CHECK-NEXT:  [[#PFS+9]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd)
+// CHECK-NEXT:  [[#PFS+9]]: lin
+// CHECK-NEXT:  [[#PFS+10]]: step
+// CHECK-NEXT:  [[#PFS+11]]: [B1.[[#PFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#PFS+12]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#PFS+3]]];
-#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd)
+#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#PAR:]]: x
 // CHECK-NEXT:  [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#PAR+2]]: argc
 // CHECK-NEXT:  [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
 // CHECK-NEXT:  [[#PAR+4]]: cond
 // CHECK-NEXT:  [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)

 #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)
   {
     argc = x;
   }
 // CHECK-NEXT:  [[#SIMD:]]: x
 // CHECK-NEXT:  [[#SIMD+1]]: [B1.[[#SIMD]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#SIMD+2]]: argc
 // CHECK-NEXT:  [[#SIMD+3]]: [B1.[[#SIMD+2]]] = [B1.[[#SIMD+1]]]
-// CHECK-NEXT:  [[#SIMD+4]]: #pragma omp simd
+// CHECK-NEXT:  [[#SIMD+4]]: lin
+// CHECK-NEXT:  [[#SIMD+5]]: step
+// CHECK-NEXT:  [[#SIMD+6]]: [B1.[[#SIMD+5]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#SIMD+7]]: #pragma omp simd linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#SIMD+3]]];
-#pragma omp simd
+#pragma omp simd linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#SINGLE:]]: x
 // CHECK-NEXT:  [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#SINGLE+2]]: argc
 // CHECK-NEXT:  [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
 // CHECK-NEXT:  [[#SINGLE+4]]: #pragma omp single
 // CHECK-NEXT:    [B1.[[#SINGLE+3]]];

 // CHECK-NEXT:  [[#TARGET+9]]: argc
 // CHECK-NEXT:  [[#TARGET+10]]: x
 // CHECK-NEXT:  [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd)
 // CHECK-NEXT:    [B1.[[#TARGET+3]]];
 #pragma omp target depend(in \
                           : argc) if(cond) firstprivate(fp) reduction(-:rd)
   argc = x;
 // CHECK-NEXT:  [[#TPF:]]:
-// CHECK-SAME:  [B1.[[#TPF+10]]]
-// CHECK-NEXT:  [[#TPF+1]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TPF+2]]: [B1.[[#TPF+9]]]
-// CHECK-NEXT:  [[#TPF+3]]: [B1.[[#TPF+9]]] = [B1.[[#TPF+1]]]
+// CHECK-SAME:  [B1.[[#TPF+13]]]
+// CHECK-NEXT:  [[#TPF+1]]: [B1.[[#TPF+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TPF+2]]: [B1.[[#TPF+12]]]
+// CHECK-NEXT:  [[#TPF+3]]: [B1.[[#TPF+12]]] = [B1.[[#TPF+1]]]
 // CHECK-NEXT:  [[#TPF+4]]: cond
 // CHECK-NEXT:  [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#TPF+7]]: fp
 // CHECK-NEXT:  [[#TPF+8]]: rd
-// CHECK-NEXT:  [[#TPF+9]]: argc
-// CHECK-NEXT:  [[#TPF+10]]: x
-// CHECK-NEXT:  [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd)
+// CHECK-NEXT:  [[#TPF+9]]: lin
+// CHECK-NEXT:  [[#TPF+10]]: step
+// CHECK-NEXT:  [[#TPF+11]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TPF+12]]: argc
+// CHECK-NEXT:  [[#TPF+13]]: x
+// CHECK-NEXT:  [[#TPF+14]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TPF+3]]];
-#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd)
+#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#TPFS:]]:
-// CHECK-SAME:  [B1.[[#TPFS+10]]]
-// CHECK-NEXT:  [[#TPFS+1]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TPFS+2]]: [B1.[[#TPFS+9]]]
-// CHECK-NEXT:  [[#TPFS+3]]: [B1.[[#TPFS+9]]] = [B1.[[#TPFS+1]]]
+// CHECK-SAME:  [B1.[[#TPFS+13]]]
+// CHECK-NEXT:  [[#TPFS+1]]: [B1.[[#TPFS+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TPFS+2]]: [B1.[[#TPFS+12]]]
+// CHECK-NEXT:  [[#TPFS+3]]: [B1.[[#TPFS+12]]] = [B1.[[#TPFS+1]]]
 // CHECK-NEXT:  [[#TPFS+4]]: cond
 // CHECK-NEXT:  [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#TPFS+7]]: fp
 // CHECK-NEXT:  [[#TPFS+8]]: rd
-// CHECK-NEXT:  [[#TPFS+9]]: argc
-// CHECK-NEXT:  [[#TPFS+10]]: x
-// CHECK-NEXT:  [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd)
+// CHECK-NEXT:  [[#TPFS+9]]: lin
+// CHECK-NEXT:  [[#TPFS+10]]: step
+// CHECK-NEXT:  [[#TPFS+11]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TPFS+12]]: argc
+// CHECK-NEXT:  [[#TPFS+13]]: x
+// CHECK-NEXT:  [[#TPFS+14]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TPFS+3]]];
-#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd)
+#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#TP:]]:
 // CHECK-SAME:  [B1.[[#TP+10]]]
 // CHECK-NEXT:  [[#TP+1]]: [B1.[[#TP+10]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TP+2]]: [B1.[[#TP+9]]]
 // CHECK-NEXT:  [[#TP+3]]: [B1.[[#TP+9]]] = [B1.[[#TP+1]]]
 // CHECK-NEXT:  [[#TP+4]]: cond
 // CHECK-NEXT:  [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#TP+7]]: fp
 // CHECK-NEXT:  [[#TP+8]]: rd
 // CHECK-NEXT:  [[#TP+9]]: argc
 // CHECK-NEXT:  [[#TP+10]]: x
 // CHECK-NEXT:  [[#TP+11]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd)
 // CHECK-NEXT:    [B1.[[#TP+3]]];
 #pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd)
   argc = x;
 // CHECK-NEXT:  [[#TSIMD:]]:
-// CHECK-SAME:  [B1.[[#TSIMD+10]]]
-// CHECK-NEXT:  [[#TSIMD+1]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TSIMD+2]]: [B1.[[#TSIMD+9]]]
-// CHECK-NEXT:  [[#TSIMD+3]]: [B1.[[#TSIMD+9]]] = [B1.[[#TSIMD+1]]]
+// CHECK-SAME:  [B1.[[#TSIMD+13]]]
+// CHECK-NEXT:  [[#TSIMD+1]]: [B1.[[#TSIMD+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TSIMD+2]]: [B1.[[#TSIMD+12]]]
+// CHECK-NEXT:  [[#TSIMD+3]]: [B1.[[#TSIMD+12]]] = [B1.[[#TSIMD+1]]]
 // CHECK-NEXT:  [[#TSIMD+4]]: cond
 // CHECK-NEXT:  [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#TSIMD+7]]: fp
 // CHECK-NEXT:  [[#TSIMD+8]]: rd
-// CHECK-NEXT:  [[#TSIMD+9]]: argc
-// CHECK-NEXT:  [[#TSIMD+10]]: x
-// CHECK-NEXT:  [[#TSIMD+11]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd)
+// CHECK-NEXT:  [[#TSIMD+9]]: lin
+// CHECK-NEXT:  [[#TSIMD+10]]: step
+// CHECK-NEXT:  [[#TSIMD+11]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TSIMD+12]]: argc
+// CHECK-NEXT:  [[#TSIMD+13]]: x
+// CHECK-NEXT:  [[#TSIMD+14]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TSIMD+3]]];
-#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd)
+#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#TTD:]]:
 // CHECK-SAME:  [B1.[[#TTD+10]]]
 // CHECK-NEXT:  [[#TTD+1]]: [B1.[[#TTD+10]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TTD+2]]: [B1.[[#TTD+9]]]
 // CHECK-NEXT:  [[#TTD+3]]: [B1.[[#TTD+9]]] = [B1.[[#TTD+1]]]
 // CHECK-NEXT:  [[#TTD+4]]: cond

 // CHECK-NEXT:  [[#TL+10]]: x
 // CHECK-NEXT:  [[#TL+11]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TL+3]]];
 #pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#TLS:]]:
-// CHECK-SAME:  [B1.[[#TLS+10]]]
-// CHECK-NEXT:  [[#TLS+1]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TLS+2]]: [B1.[[#TLS+9]]]
-// CHECK-NEXT:  [[#TLS+3]]: [B1.[[#TLS+9]]] = [B1.[[#TLS+1]]]
+// CHECK-SAME:  [B1.[[#TLS+13]]]
+// CHECK-NEXT:  [[#TLS+1]]: [B1.[[#TLS+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TLS+2]]: [B1.[[#TLS+12]]]
+// CHECK-NEXT:  [[#TLS+3]]: [B1.[[#TLS+12]]] = [B1.[[#TLS+1]]]
 // CHECK-NEXT:  [[#TLS+4]]: cond
 // CHECK-NEXT:  [[#TLS+5]]: [B1.[[#TLS+4]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TLS+6]]: [B1.[[#TLS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:  [[#TLS+7]]: fp
 // CHECK-NEXT:  [[#TLS+8]]: rd
-// CHECK-NEXT:  [[#TLS+9]]: argc
-// CHECK-NEXT:  [[#TLS+10]]: x
-// CHECK-NEXT:  [[#TLS+11]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd)
+// CHECK-NEXT:  [[#TLS+9]]: lin
+// CHECK-NEXT:  [[#TLS+10]]: step
+// CHECK-NEXT:  [[#TLS+11]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TLS+12]]: argc
+// CHECK-NEXT:  [[#TLS+13]]: x
+// CHECK-NEXT:  [[#TLS+14]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TLS+3]]];
-#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd)
+#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#TDPF:]]: x
 // CHECK-NEXT:  [[#TDPF+1]]: [B1.[[#TDPF]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:  [[#TDPF+2]]: argc
 // CHECK-NEXT:  [[#TDPF+3]]: [B1.[[#TDPF+2]]] = [B1.[[#TDPF+1]]]
 // CHECK-NEXT:  [[#TDPF+4]]: cond
 // CHECK-NEXT:  [[#TDPF+5]]: [B1.[[#TDPF+4]]] (ImplicitCastExpr, LValueToRValue, int)

test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-target -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-target -Wuninitialized
 
 extern int omp_default_mem_alloc;
+
+void xxx(int argc) {
+  int i;
+#pragma omp distribute parallel for simd linear(i)
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/distribute_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+
+void xxx(int argc) {
+  int i;
+#pragma omp distribute simd linear(i)
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/for_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp for linear(lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/for_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp for simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/parallel_for_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp parallel for linear(lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
 int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/parallel_for_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp parallel for simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/target_parallel_for_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
 extern const omp_allocator_handle_t omp_const_mem_alloc;
 extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp target parallel for linear(lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
 int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/target_parallel_for_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
 extern const omp_allocator_handle_t omp_const_mem_alloc;
 extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp target parallel for simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
 int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/target_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
 extern const omp_allocator_handle_t omp_const_mem_alloc;
 extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp target simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
 int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/target_teams_distribute_parallel_for_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
 extern const omp_allocator_handle_t omp_const_mem_alloc;
 extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
+void xxx(int argc) {
+  int i, step; // expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp target teams distribute parallel for simd linear(i : step) // expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/target_teams_distribute_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
 extern const omp_allocator_handle_t omp_const_mem_alloc;
 extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
+void xxx(int argc) {
+  int i, step; // expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp target teams distribute simd linear(i : step) // expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/taskloop_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
 extern const omp_allocator_handle_t omp_const_mem_alloc;
 extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
+void xxx(int argc) {
+  int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
+#pragma omp taskloop simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/teams_distribute_parallel_for_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+void xxx(int argc) {
+  int i, step; // expected-note {{initialize the variable 'step' to silence this warning}} expected-note {{initialize the variable 'i' to silence this warning}}
+#pragma omp target
+#pragma omp teams distribute parallel for simd linear(i : step) // expected-warning {{variable 'i' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };

test/OpenMP/teams_distribute_simd_linear_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
+void xxx(int argc) {
+  int i, step; // expected-note {{initialize the variable 'step' to silence this warning}} expected-note {{initialize the variable 'i' to silence this warning}}
+#pragma omp target
+#pragma omp teams distribute simd linear(i : step) // expected-warning {{variable 'i' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
+  for (i = 0; i < 10; ++i)
+    ;
+}
+
 namespace X {
   int x;
 };
 
 struct B {
   static int ib; // expected-note {{'B::ib' declared here}}
   static int bfoo() { return 8; }
 };