• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// \brief This file implements semantic analysis for OpenMP directives and
11 /// clauses.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "TreeTransform.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTMutationListener.h"
18 #include "clang/AST/CXXInheritance.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclOpenMP.h"
22 #include "clang/AST/StmtCXX.h"
23 #include "clang/AST/StmtOpenMP.h"
24 #include "clang/AST/StmtVisitor.h"
25 #include "clang/AST/TypeOrdering.h"
26 #include "clang/Basic/OpenMPKinds.h"
27 #include "clang/Basic/TargetInfo.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Sema/Initialization.h"
30 #include "clang/Sema/Lookup.h"
31 #include "clang/Sema/Scope.h"
32 #include "clang/Sema/ScopeInfo.h"
33 #include "clang/Sema/SemaInternal.h"
34 using namespace clang;
35 
36 //===----------------------------------------------------------------------===//
37 // Stack of data-sharing attributes for variables
38 //===----------------------------------------------------------------------===//
39 
40 namespace {
41 /// \brief Default data sharing attributes, which can be applied to directive.
42 enum DefaultDataSharingAttributes {
43   DSA_unspecified = 0, /// \brief Data sharing attribute not specified.
44   DSA_none = 1 << 0,   /// \brief Default data sharing attribute 'none'.
45   DSA_shared = 1 << 1  /// \brief Default data sharing attribute 'shared'.
46 };
47 
48 /// \brief Stack for tracking declarations used in OpenMP directives and
49 /// clauses and their data-sharing attributes.
50 class DSAStackTy final {
51 public:
52   struct DSAVarData final {
53     OpenMPDirectiveKind DKind = OMPD_unknown;
54     OpenMPClauseKind CKind = OMPC_unknown;
55     Expr *RefExpr = nullptr;
56     DeclRefExpr *PrivateCopy = nullptr;
57     SourceLocation ImplicitDSALoc;
DSAVarData__anon94996c650111::DSAStackTy::DSAVarData58     DSAVarData() {}
59   };
60   typedef llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4>
61       OperatorOffsetTy;
62 
63 private:
64   struct DSAInfo final {
65     OpenMPClauseKind Attributes = OMPC_unknown;
66     /// Pointer to a reference expression and a flag which shows that the
67     /// variable is marked as lastprivate(true) or not (false).
68     llvm::PointerIntPair<Expr *, 1, bool> RefExpr;
69     DeclRefExpr *PrivateCopy = nullptr;
70   };
71   typedef llvm::DenseMap<ValueDecl *, DSAInfo> DeclSAMapTy;
72   typedef llvm::DenseMap<ValueDecl *, Expr *> AlignedMapTy;
73   typedef std::pair<unsigned, VarDecl *> LCDeclInfo;
74   typedef llvm::DenseMap<ValueDecl *, LCDeclInfo> LoopControlVariablesMapTy;
75   typedef llvm::DenseMap<
76       ValueDecl *, OMPClauseMappableExprCommon::MappableExprComponentLists>
77       MappedExprComponentsTy;
78   typedef llvm::StringMap<std::pair<OMPCriticalDirective *, llvm::APSInt>>
79       CriticalsWithHintsTy;
80   typedef llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>
81       DoacrossDependMapTy;
82 
83   struct SharingMapTy final {
84     DeclSAMapTy SharingMap;
85     AlignedMapTy AlignedMap;
86     MappedExprComponentsTy MappedExprComponents;
87     LoopControlVariablesMapTy LCVMap;
88     DefaultDataSharingAttributes DefaultAttr = DSA_unspecified;
89     SourceLocation DefaultAttrLoc;
90     OpenMPDirectiveKind Directive = OMPD_unknown;
91     DeclarationNameInfo DirectiveName;
92     Scope *CurScope = nullptr;
93     SourceLocation ConstructLoc;
94     /// Set of 'depend' clauses with 'sink|source' dependence kind. Required to
95     /// get the data (loop counters etc.) about enclosing loop-based construct.
96     /// This data is required during codegen.
97     DoacrossDependMapTy DoacrossDepends;
98     /// \brief first argument (Expr *) contains optional argument of the
99     /// 'ordered' clause, the second one is true if the regions has 'ordered'
100     /// clause, false otherwise.
101     llvm::PointerIntPair<Expr *, 1, bool> OrderedRegion;
102     bool NowaitRegion = false;
103     bool CancelRegion = false;
104     unsigned AssociatedLoops = 1;
105     SourceLocation InnerTeamsRegionLoc;
SharingMapTy__anon94996c650111::DSAStackTy::SharingMapTy106     SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name,
107                  Scope *CurScope, SourceLocation Loc)
108         : Directive(DKind), DirectiveName(Name), CurScope(CurScope),
109           ConstructLoc(Loc) {}
SharingMapTy__anon94996c650111::DSAStackTy::SharingMapTy110     SharingMapTy() {}
111   };
112 
113   typedef SmallVector<SharingMapTy, 4> StackTy;
114 
115   /// \brief Stack of used declaration and their data-sharing attributes.
116   StackTy Stack;
117   /// \brief true, if check for DSA must be from parent directive, false, if
118   /// from current directive.
119   OpenMPClauseKind ClauseKindMode = OMPC_unknown;
120   Sema &SemaRef;
121   bool ForceCapturing = false;
122   CriticalsWithHintsTy Criticals;
123 
124   typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator;
125 
126   DSAVarData getDSA(StackTy::reverse_iterator& Iter, ValueDecl *D);
127 
128   /// \brief Checks if the variable is a local for OpenMP region.
129   bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter);
130 
131 public:
DSAStackTy(Sema & S)132   explicit DSAStackTy(Sema &S) : Stack(1), SemaRef(S) {}
133 
isClauseParsingMode() const134   bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
setClauseParsingMode(OpenMPClauseKind K)135   void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }
136 
isForceVarCapturing() const137   bool isForceVarCapturing() const { return ForceCapturing; }
setForceVarCapturing(bool V)138   void setForceVarCapturing(bool V) { ForceCapturing = V; }
139 
push(OpenMPDirectiveKind DKind,const DeclarationNameInfo & DirName,Scope * CurScope,SourceLocation Loc)140   void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
141             Scope *CurScope, SourceLocation Loc) {
142     Stack.push_back(SharingMapTy(DKind, DirName, CurScope, Loc));
143     Stack.back().DefaultAttrLoc = Loc;
144   }
145 
pop()146   void pop() {
147     assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!");
148     Stack.pop_back();
149   }
150 
addCriticalWithHint(OMPCriticalDirective * D,llvm::APSInt Hint)151   void addCriticalWithHint(OMPCriticalDirective *D, llvm::APSInt Hint) {
152     Criticals[D->getDirectiveName().getAsString()] = std::make_pair(D, Hint);
153   }
154   const std::pair<OMPCriticalDirective *, llvm::APSInt>
getCriticalWithHint(const DeclarationNameInfo & Name) const155   getCriticalWithHint(const DeclarationNameInfo &Name) const {
156     auto I = Criticals.find(Name.getAsString());
157     if (I != Criticals.end())
158       return I->second;
159     return std::make_pair(nullptr, llvm::APSInt());
160   }
161   /// \brief If 'aligned' declaration for given variable \a D was not seen yet,
162   /// add it and return NULL; otherwise return previous occurrence's expression
163   /// for diagnostics.
164   Expr *addUniqueAligned(ValueDecl *D, Expr *NewDE);
165 
166   /// \brief Register specified variable as loop control variable.
167   void addLoopControlVariable(ValueDecl *D, VarDecl *Capture);
168   /// \brief Check if the specified variable is a loop control variable for
169   /// current region.
170   /// \return The index of the loop control variable in the list of associated
171   /// for-loops (from outer to inner).
172   LCDeclInfo isLoopControlVariable(ValueDecl *D);
173   /// \brief Check if the specified variable is a loop control variable for
174   /// parent region.
175   /// \return The index of the loop control variable in the list of associated
176   /// for-loops (from outer to inner).
177   LCDeclInfo isParentLoopControlVariable(ValueDecl *D);
178   /// \brief Get the loop control variable for the I-th loop (or nullptr) in
179   /// parent directive.
180   ValueDecl *getParentLoopControlVariable(unsigned I);
181 
182   /// \brief Adds explicit data sharing attribute to the specified declaration.
183   void addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
184               DeclRefExpr *PrivateCopy = nullptr);
185 
186   /// \brief Returns data sharing attributes from top of the stack for the
187   /// specified declaration.
188   DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
189   /// \brief Returns data-sharing attributes for the specified declaration.
190   DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent);
191   /// \brief Checks if the specified variables has data-sharing attributes which
192   /// match specified \a CPred predicate in any directive which matches \a DPred
193   /// predicate.
194   DSAVarData hasDSA(ValueDecl *D,
195                     const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
196                     const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
197                     bool FromParent);
198   /// \brief Checks if the specified variables has data-sharing attributes which
199   /// match specified \a CPred predicate in any innermost directive which
200   /// matches \a DPred predicate.
201   DSAVarData
202   hasInnermostDSA(ValueDecl *D,
203                   const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
204                   const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
205                   bool FromParent);
206   /// \brief Checks if the specified variables has explicit data-sharing
207   /// attributes which match specified \a CPred predicate at the specified
208   /// OpenMP region.
209   bool hasExplicitDSA(ValueDecl *D,
210                       const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
211                       unsigned Level, bool NotLastprivate = false);
212 
213   /// \brief Returns true if the directive at level \Level matches in the
214   /// specified \a DPred predicate.
215   bool hasExplicitDirective(
216       const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
217       unsigned Level);
218 
219   /// \brief Finds a directive which matches specified \a DPred predicate.
220   bool hasDirective(const llvm::function_ref<bool(OpenMPDirectiveKind,
221                                                   const DeclarationNameInfo &,
222                                                   SourceLocation)> &DPred,
223                     bool FromParent);
224 
225   /// \brief Returns currently analyzed directive.
getCurrentDirective() const226   OpenMPDirectiveKind getCurrentDirective() const {
227     return Stack.back().Directive;
228   }
229   /// \brief Returns parent directive.
getParentDirective() const230   OpenMPDirectiveKind getParentDirective() const {
231     if (Stack.size() > 2)
232       return Stack[Stack.size() - 2].Directive;
233     return OMPD_unknown;
234   }
235 
236   /// \brief Set default data sharing attribute to none.
setDefaultDSANone(SourceLocation Loc)237   void setDefaultDSANone(SourceLocation Loc) {
238     Stack.back().DefaultAttr = DSA_none;
239     Stack.back().DefaultAttrLoc = Loc;
240   }
241   /// \brief Set default data sharing attribute to shared.
setDefaultDSAShared(SourceLocation Loc)242   void setDefaultDSAShared(SourceLocation Loc) {
243     Stack.back().DefaultAttr = DSA_shared;
244     Stack.back().DefaultAttrLoc = Loc;
245   }
246 
getDefaultDSA() const247   DefaultDataSharingAttributes getDefaultDSA() const {
248     return Stack.back().DefaultAttr;
249   }
getDefaultDSALocation() const250   SourceLocation getDefaultDSALocation() const {
251     return Stack.back().DefaultAttrLoc;
252   }
253 
254   /// \brief Checks if the specified variable is a threadprivate.
isThreadPrivate(VarDecl * D)255   bool isThreadPrivate(VarDecl *D) {
256     DSAVarData DVar = getTopDSA(D, false);
257     return isOpenMPThreadPrivate(DVar.CKind);
258   }
259 
260   /// \brief Marks current region as ordered (it has an 'ordered' clause).
setOrderedRegion(bool IsOrdered,Expr * Param)261   void setOrderedRegion(bool IsOrdered, Expr *Param) {
262     Stack.back().OrderedRegion.setInt(IsOrdered);
263     Stack.back().OrderedRegion.setPointer(Param);
264   }
265   /// \brief Returns true, if parent region is ordered (has associated
266   /// 'ordered' clause), false - otherwise.
isParentOrderedRegion() const267   bool isParentOrderedRegion() const {
268     if (Stack.size() > 2)
269       return Stack[Stack.size() - 2].OrderedRegion.getInt();
270     return false;
271   }
272   /// \brief Returns optional parameter for the ordered region.
getParentOrderedRegionParam() const273   Expr *getParentOrderedRegionParam() const {
274     if (Stack.size() > 2)
275       return Stack[Stack.size() - 2].OrderedRegion.getPointer();
276     return nullptr;
277   }
278   /// \brief Marks current region as nowait (it has a 'nowait' clause).
setNowaitRegion(bool IsNowait=true)279   void setNowaitRegion(bool IsNowait = true) {
280     Stack.back().NowaitRegion = IsNowait;
281   }
282   /// \brief Returns true, if parent region is nowait (has associated
283   /// 'nowait' clause), false - otherwise.
isParentNowaitRegion() const284   bool isParentNowaitRegion() const {
285     if (Stack.size() > 2)
286       return Stack[Stack.size() - 2].NowaitRegion;
287     return false;
288   }
289   /// \brief Marks parent region as cancel region.
setParentCancelRegion(bool Cancel=true)290   void setParentCancelRegion(bool Cancel = true) {
291     if (Stack.size() > 2)
292       Stack[Stack.size() - 2].CancelRegion =
293           Stack[Stack.size() - 2].CancelRegion || Cancel;
294   }
295   /// \brief Return true if current region has inner cancel construct.
isCancelRegion() const296   bool isCancelRegion() const {
297     return Stack.back().CancelRegion;
298   }
299 
300   /// \brief Set collapse value for the region.
setAssociatedLoops(unsigned Val)301   void setAssociatedLoops(unsigned Val) { Stack.back().AssociatedLoops = Val; }
302   /// \brief Return collapse value for region.
getAssociatedLoops() const303   unsigned getAssociatedLoops() const { return Stack.back().AssociatedLoops; }
304 
305   /// \brief Marks current target region as one with closely nested teams
306   /// region.
setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc)307   void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
308     if (Stack.size() > 2)
309       Stack[Stack.size() - 2].InnerTeamsRegionLoc = TeamsRegionLoc;
310   }
311   /// \brief Returns true, if current region has closely nested teams region.
hasInnerTeamsRegion() const312   bool hasInnerTeamsRegion() const {
313     return getInnerTeamsRegionLoc().isValid();
314   }
315   /// \brief Returns location of the nested teams region (if any).
getInnerTeamsRegionLoc() const316   SourceLocation getInnerTeamsRegionLoc() const {
317     if (Stack.size() > 1)
318       return Stack.back().InnerTeamsRegionLoc;
319     return SourceLocation();
320   }
321 
getCurScope() const322   Scope *getCurScope() const { return Stack.back().CurScope; }
getCurScope()323   Scope *getCurScope() { return Stack.back().CurScope; }
getConstructLoc()324   SourceLocation getConstructLoc() { return Stack.back().ConstructLoc; }
325 
326   // Do the check specified in \a Check to all component lists and return true
327   // if any issue is found.
checkMappableExprComponentListsForDecl(ValueDecl * VD,bool CurrentRegionOnly,const llvm::function_ref<bool (OMPClauseMappableExprCommon::MappableExprComponentListRef)> & Check)328   bool checkMappableExprComponentListsForDecl(
329       ValueDecl *VD, bool CurrentRegionOnly,
330       const llvm::function_ref<bool(
331           OMPClauseMappableExprCommon::MappableExprComponentListRef)> &Check) {
332     auto SI = Stack.rbegin();
333     auto SE = Stack.rend();
334 
335     if (SI == SE)
336       return false;
337 
338     if (CurrentRegionOnly) {
339       SE = std::next(SI);
340     } else {
341       ++SI;
342     }
343 
344     for (; SI != SE; ++SI) {
345       auto MI = SI->MappedExprComponents.find(VD);
346       if (MI != SI->MappedExprComponents.end())
347         for (auto &L : MI->second)
348           if (Check(L))
349             return true;
350     }
351     return false;
352   }
353 
354   // Create a new mappable expression component list associated with a given
355   // declaration and initialize it with the provided list of components.
addMappableExpressionComponents(ValueDecl * VD,OMPClauseMappableExprCommon::MappableExprComponentListRef Components)356   void addMappableExpressionComponents(
357       ValueDecl *VD,
358       OMPClauseMappableExprCommon::MappableExprComponentListRef Components) {
359     assert(Stack.size() > 1 &&
360            "Not expecting to retrieve components from a empty stack!");
361     auto &MEC = Stack.back().MappedExprComponents[VD];
362     // Create new entry and append the new components there.
363     MEC.resize(MEC.size() + 1);
364     MEC.back().append(Components.begin(), Components.end());
365   }
366 
getNestingLevel() const367   unsigned getNestingLevel() const {
368     assert(Stack.size() > 1);
369     return Stack.size() - 2;
370   }
addDoacrossDependClause(OMPDependClause * C,OperatorOffsetTy & OpsOffs)371   void addDoacrossDependClause(OMPDependClause *C, OperatorOffsetTy &OpsOffs) {
372     assert(Stack.size() > 2);
373     assert(isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive));
374     Stack[Stack.size() - 2].DoacrossDepends.insert({C, OpsOffs});
375   }
376   llvm::iterator_range<DoacrossDependMapTy::const_iterator>
getDoacrossDependClauses() const377   getDoacrossDependClauses() const {
378     assert(Stack.size() > 1);
379     if (isOpenMPWorksharingDirective(Stack[Stack.size() - 1].Directive)) {
380       auto &Ref = Stack[Stack.size() - 1].DoacrossDepends;
381       return llvm::make_range(Ref.begin(), Ref.end());
382     }
383     return llvm::make_range(Stack[0].DoacrossDepends.end(),
384                             Stack[0].DoacrossDepends.end());
385   }
386 };
isParallelOrTaskRegion(OpenMPDirectiveKind DKind)387 bool isParallelOrTaskRegion(OpenMPDirectiveKind DKind) {
388   return isOpenMPParallelDirective(DKind) || isOpenMPTaskingDirective(DKind) ||
389          isOpenMPTeamsDirective(DKind) || DKind == OMPD_unknown;
390 }
391 } // namespace
392 
getCanonicalDecl(ValueDecl * D)393 static ValueDecl *getCanonicalDecl(ValueDecl *D) {
394   auto *VD = dyn_cast<VarDecl>(D);
395   auto *FD = dyn_cast<FieldDecl>(D);
396   if (VD  != nullptr) {
397     VD = VD->getCanonicalDecl();
398     D = VD;
399   } else {
400     assert(FD);
401     FD = FD->getCanonicalDecl();
402     D = FD;
403   }
404   return D;
405 }
406 
getDSA(StackTy::reverse_iterator & Iter,ValueDecl * D)407 DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator& Iter,
408                                           ValueDecl *D) {
409   D = getCanonicalDecl(D);
410   auto *VD = dyn_cast<VarDecl>(D);
411   auto *FD = dyn_cast<FieldDecl>(D);
412   DSAVarData DVar;
413   if (Iter == std::prev(Stack.rend())) {
414     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
415     // in a region but not in construct]
416     //  File-scope or namespace-scope variables referenced in called routines
417     //  in the region are shared unless they appear in a threadprivate
418     //  directive.
419     if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(D))
420       DVar.CKind = OMPC_shared;
421 
422     // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
423     // in a region but not in construct]
424     //  Variables with static storage duration that are declared in called
425     //  routines in the region are shared.
426     if (VD && VD->hasGlobalStorage())
427       DVar.CKind = OMPC_shared;
428 
429     // Non-static data members are shared by default.
430     if (FD)
431       DVar.CKind = OMPC_shared;
432 
433     return DVar;
434   }
435 
436   DVar.DKind = Iter->Directive;
437   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
438   // in a Construct, C/C++, predetermined, p.1]
439   // Variables with automatic storage duration that are declared in a scope
440   // inside the construct are private.
441   if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
442       (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
443     DVar.CKind = OMPC_private;
444     return DVar;
445   }
446 
447   // Explicitly specified attributes and local variables with predetermined
448   // attributes.
449   if (Iter->SharingMap.count(D)) {
450     DVar.RefExpr = Iter->SharingMap[D].RefExpr.getPointer();
451     DVar.PrivateCopy = Iter->SharingMap[D].PrivateCopy;
452     DVar.CKind = Iter->SharingMap[D].Attributes;
453     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
454     return DVar;
455   }
456 
457   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
458   // in a Construct, C/C++, implicitly determined, p.1]
459   //  In a parallel or task construct, the data-sharing attributes of these
460   //  variables are determined by the default clause, if present.
461   switch (Iter->DefaultAttr) {
462   case DSA_shared:
463     DVar.CKind = OMPC_shared;
464     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
465     return DVar;
466   case DSA_none:
467     return DVar;
468   case DSA_unspecified:
469     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
470     // in a Construct, implicitly determined, p.2]
471     //  In a parallel construct, if no default clause is present, these
472     //  variables are shared.
473     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
474     if (isOpenMPParallelDirective(DVar.DKind) ||
475         isOpenMPTeamsDirective(DVar.DKind)) {
476       DVar.CKind = OMPC_shared;
477       return DVar;
478     }
479 
480     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
481     // in a Construct, implicitly determined, p.4]
482     //  In a task construct, if no default clause is present, a variable that in
483     //  the enclosing context is determined to be shared by all implicit tasks
484     //  bound to the current team is shared.
485     if (isOpenMPTaskingDirective(DVar.DKind)) {
486       DSAVarData DVarTemp;
487       for (StackTy::reverse_iterator I = std::next(Iter), EE = Stack.rend();
488            I != EE; ++I) {
489         // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
490         // Referenced in a Construct, implicitly determined, p.6]
491         //  In a task construct, if no default clause is present, a variable
492         //  whose data-sharing attribute is not determined by the rules above is
493         //  firstprivate.
494         DVarTemp = getDSA(I, D);
495         if (DVarTemp.CKind != OMPC_shared) {
496           DVar.RefExpr = nullptr;
497           DVar.CKind = OMPC_firstprivate;
498           return DVar;
499         }
500         if (isParallelOrTaskRegion(I->Directive))
501           break;
502       }
503       DVar.CKind =
504           (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
505       return DVar;
506     }
507   }
508   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
509   // in a Construct, implicitly determined, p.3]
510   //  For constructs other than task, if no default clause is present, these
511   //  variables inherit their data-sharing attributes from the enclosing
512   //  context.
513   return getDSA(++Iter, D);
514 }
515 
addUniqueAligned(ValueDecl * D,Expr * NewDE)516 Expr *DSAStackTy::addUniqueAligned(ValueDecl *D, Expr *NewDE) {
517   assert(Stack.size() > 1 && "Data sharing attributes stack is empty");
518   D = getCanonicalDecl(D);
519   auto It = Stack.back().AlignedMap.find(D);
520   if (It == Stack.back().AlignedMap.end()) {
521     assert(NewDE && "Unexpected nullptr expr to be added into aligned map");
522     Stack.back().AlignedMap[D] = NewDE;
523     return nullptr;
524   } else {
525     assert(It->second && "Unexpected nullptr expr in the aligned map");
526     return It->second;
527   }
528   return nullptr;
529 }
530 
addLoopControlVariable(ValueDecl * D,VarDecl * Capture)531 void DSAStackTy::addLoopControlVariable(ValueDecl *D, VarDecl *Capture) {
532   assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
533   D = getCanonicalDecl(D);
534   Stack.back().LCVMap.insert(
535       std::make_pair(D, LCDeclInfo(Stack.back().LCVMap.size() + 1, Capture)));
536 }
537 
isLoopControlVariable(ValueDecl * D)538 DSAStackTy::LCDeclInfo DSAStackTy::isLoopControlVariable(ValueDecl *D) {
539   assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
540   D = getCanonicalDecl(D);
541   return Stack.back().LCVMap.count(D) > 0 ? Stack.back().LCVMap[D]
542                                           : LCDeclInfo(0, nullptr);
543 }
544 
isParentLoopControlVariable(ValueDecl * D)545 DSAStackTy::LCDeclInfo DSAStackTy::isParentLoopControlVariable(ValueDecl *D) {
546   assert(Stack.size() > 2 && "Data-sharing attributes stack is empty");
547   D = getCanonicalDecl(D);
548   return Stack[Stack.size() - 2].LCVMap.count(D) > 0
549              ? Stack[Stack.size() - 2].LCVMap[D]
550              : LCDeclInfo(0, nullptr);
551 }
552 
getParentLoopControlVariable(unsigned I)553 ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) {
554   assert(Stack.size() > 2 && "Data-sharing attributes stack is empty");
555   if (Stack[Stack.size() - 2].LCVMap.size() < I)
556     return nullptr;
557   for (auto &Pair : Stack[Stack.size() - 2].LCVMap) {
558     if (Pair.second.first == I)
559       return Pair.first;
560   }
561   return nullptr;
562 }
563 
addDSA(ValueDecl * D,Expr * E,OpenMPClauseKind A,DeclRefExpr * PrivateCopy)564 void DSAStackTy::addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
565                         DeclRefExpr *PrivateCopy) {
566   D = getCanonicalDecl(D);
567   if (A == OMPC_threadprivate) {
568     auto &Data = Stack[0].SharingMap[D];
569     Data.Attributes = A;
570     Data.RefExpr.setPointer(E);
571     Data.PrivateCopy = nullptr;
572   } else {
573     assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
574     auto &Data = Stack.back().SharingMap[D];
575     assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
576            (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||
577            (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||
578            (isLoopControlVariable(D).first && A == OMPC_private));
579     if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
580       Data.RefExpr.setInt(/*IntVal=*/true);
581       return;
582     }
583     const bool IsLastprivate =
584         A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
585     Data.Attributes = A;
586     Data.RefExpr.setPointerAndInt(E, IsLastprivate);
587     Data.PrivateCopy = PrivateCopy;
588     if (PrivateCopy) {
589       auto &Data = Stack.back().SharingMap[PrivateCopy->getDecl()];
590       Data.Attributes = A;
591       Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
592       Data.PrivateCopy = nullptr;
593     }
594   }
595 }
596 
isOpenMPLocal(VarDecl * D,StackTy::reverse_iterator Iter)597 bool DSAStackTy::isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter) {
598   D = D->getCanonicalDecl();
599   if (Stack.size() > 2) {
600     reverse_iterator I = Iter, E = std::prev(Stack.rend());
601     Scope *TopScope = nullptr;
602     while (I != E && !isParallelOrTaskRegion(I->Directive)) {
603       ++I;
604     }
605     if (I == E)
606       return false;
607     TopScope = I->CurScope ? I->CurScope->getParent() : nullptr;
608     Scope *CurScope = getCurScope();
609     while (CurScope != TopScope && !CurScope->isDeclScope(D)) {
610       CurScope = CurScope->getParent();
611     }
612     return CurScope != TopScope;
613   }
614   return false;
615 }
616 
617 /// \brief Build a variable declaration for OpenMP loop iteration variable.
buildVarDecl(Sema & SemaRef,SourceLocation Loc,QualType Type,StringRef Name,const AttrVec * Attrs=nullptr)618 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
619                              StringRef Name, const AttrVec *Attrs = nullptr) {
620   DeclContext *DC = SemaRef.CurContext;
621   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
622   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
623   VarDecl *Decl =
624       VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
625   if (Attrs) {
626     for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
627          I != E; ++I)
628       Decl->addAttr(*I);
629   }
630   Decl->setImplicit();
631   return Decl;
632 }
633 
buildDeclRefExpr(Sema & S,VarDecl * D,QualType Ty,SourceLocation Loc,bool RefersToCapture=false)634 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
635                                      SourceLocation Loc,
636                                      bool RefersToCapture = false) {
637   D->setReferenced();
638   D->markUsed(S.Context);
639   return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
640                              SourceLocation(), D, RefersToCapture, Loc, Ty,
641                              VK_LValue);
642 }
643 
getTopDSA(ValueDecl * D,bool FromParent)644 DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D, bool FromParent) {
645   D = getCanonicalDecl(D);
646   DSAVarData DVar;
647 
648   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
649   // in a Construct, C/C++, predetermined, p.1]
650   //  Variables appearing in threadprivate directives are threadprivate.
651   auto *VD = dyn_cast<VarDecl>(D);
652   if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
653        !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
654          SemaRef.getLangOpts().OpenMPUseTLS &&
655          SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
656       (VD && VD->getStorageClass() == SC_Register &&
657        VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
658     addDSA(D, buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
659                                D->getLocation()),
660            OMPC_threadprivate);
661   }
662   if (Stack[0].SharingMap.count(D)) {
663     DVar.RefExpr = Stack[0].SharingMap[D].RefExpr.getPointer();
664     DVar.CKind = OMPC_threadprivate;
665     return DVar;
666   }
667 
668   if (Stack.size() == 1) {
669     // Not in OpenMP execution region and top scope was already checked.
670     return DVar;
671   }
672 
673   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
674   // in a Construct, C/C++, predetermined, p.4]
675   //  Static data members are shared.
676   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
677   // in a Construct, C/C++, predetermined, p.7]
678   //  Variables with static storage duration that are declared in a scope
679   //  inside the construct are shared.
680   auto &&MatchesAlways = [](OpenMPDirectiveKind) -> bool { return true; };
681   if (VD && VD->isStaticDataMember()) {
682     DSAVarData DVarTemp = hasDSA(D, isOpenMPPrivate, MatchesAlways, FromParent);
683     if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
684       return DVar;
685 
686     DVar.CKind = OMPC_shared;
687     return DVar;
688   }
689 
690   QualType Type = D->getType().getNonReferenceType().getCanonicalType();
691   bool IsConstant = Type.isConstant(SemaRef.getASTContext());
692   Type = SemaRef.getASTContext().getBaseElementType(Type);
693   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
694   // in a Construct, C/C++, predetermined, p.6]
695   //  Variables with const qualified type having no mutable member are
696   //  shared.
697   CXXRecordDecl *RD =
698       SemaRef.getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr;
699   if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
700     if (auto *CTD = CTSD->getSpecializedTemplate())
701       RD = CTD->getTemplatedDecl();
702   if (IsConstant &&
703       !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() &&
704         RD->hasMutableFields())) {
705     // Variables with const-qualified type having no mutable member may be
706     // listed in a firstprivate clause, even if they are static data members.
707     DSAVarData DVarTemp = hasDSA(
708         D, [](OpenMPClauseKind C) -> bool { return C == OMPC_firstprivate; },
709         MatchesAlways, FromParent);
710     if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr)
711       return DVar;
712 
713     DVar.CKind = OMPC_shared;
714     return DVar;
715   }
716 
717   // Explicitly specified attributes and local variables with predetermined
718   // attributes.
719   auto StartI = std::next(Stack.rbegin());
720   auto EndI = std::prev(Stack.rend());
721   if (FromParent && StartI != EndI) {
722     StartI = std::next(StartI);
723   }
724   auto I = std::prev(StartI);
725   if (I->SharingMap.count(D)) {
726     DVar.RefExpr = I->SharingMap[D].RefExpr.getPointer();
727     DVar.PrivateCopy = I->SharingMap[D].PrivateCopy;
728     DVar.CKind = I->SharingMap[D].Attributes;
729     DVar.ImplicitDSALoc = I->DefaultAttrLoc;
730   }
731 
732   return DVar;
733 }
734 
getImplicitDSA(ValueDecl * D,bool FromParent)735 DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
736                                                   bool FromParent) {
737   D = getCanonicalDecl(D);
738   auto StartI = Stack.rbegin();
739   auto EndI = std::prev(Stack.rend());
740   if (FromParent && StartI != EndI) {
741     StartI = std::next(StartI);
742   }
743   return getDSA(StartI, D);
744 }
745 
746 DSAStackTy::DSAVarData
hasDSA(ValueDecl * D,const llvm::function_ref<bool (OpenMPClauseKind)> & CPred,const llvm::function_ref<bool (OpenMPDirectiveKind)> & DPred,bool FromParent)747 DSAStackTy::hasDSA(ValueDecl *D,
748                    const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
749                    const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
750                    bool FromParent) {
751   D = getCanonicalDecl(D);
752   auto StartI = std::next(Stack.rbegin());
753   auto EndI = Stack.rend();
754   if (FromParent && StartI != EndI) {
755     StartI = std::next(StartI);
756   }
757   for (auto I = StartI, EE = EndI; I != EE; ++I) {
758     if (!DPred(I->Directive) && !isParallelOrTaskRegion(I->Directive))
759       continue;
760     DSAVarData DVar = getDSA(I, D);
761     if (CPred(DVar.CKind))
762       return DVar;
763   }
764   return DSAVarData();
765 }
766 
hasInnermostDSA(ValueDecl * D,const llvm::function_ref<bool (OpenMPClauseKind)> & CPred,const llvm::function_ref<bool (OpenMPDirectiveKind)> & DPred,bool FromParent)767 DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
768     ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
769     const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
770     bool FromParent) {
771   D = getCanonicalDecl(D);
772   auto StartI = std::next(Stack.rbegin());
773   auto EndI = Stack.rend();
774   if (FromParent && StartI != EndI) {
775     StartI = std::next(StartI);
776   }
777   for (auto I = StartI, EE = EndI; I != EE; ++I) {
778     if (!DPred(I->Directive))
779       break;
780     DSAVarData DVar = getDSA(I, D);
781     if (CPred(DVar.CKind))
782       return DVar;
783     return DSAVarData();
784   }
785   return DSAVarData();
786 }
787 
hasExplicitDSA(ValueDecl * D,const llvm::function_ref<bool (OpenMPClauseKind)> & CPred,unsigned Level,bool NotLastprivate)788 bool DSAStackTy::hasExplicitDSA(
789     ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
790     unsigned Level, bool NotLastprivate) {
791   if (CPred(ClauseKindMode))
792     return true;
793   D = getCanonicalDecl(D);
794   auto StartI = std::next(Stack.begin());
795   auto EndI = Stack.end();
796   if (std::distance(StartI, EndI) <= (int)Level)
797     return false;
798   std::advance(StartI, Level);
799   return (StartI->SharingMap.count(D) > 0) &&
800          StartI->SharingMap[D].RefExpr.getPointer() &&
801          CPred(StartI->SharingMap[D].Attributes) &&
802          (!NotLastprivate || !StartI->SharingMap[D].RefExpr.getInt());
803 }
804 
hasExplicitDirective(const llvm::function_ref<bool (OpenMPDirectiveKind)> & DPred,unsigned Level)805 bool DSAStackTy::hasExplicitDirective(
806     const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
807     unsigned Level) {
808   auto StartI = std::next(Stack.begin());
809   auto EndI = Stack.end();
810   if (std::distance(StartI, EndI) <= (int)Level)
811     return false;
812   std::advance(StartI, Level);
813   return DPred(StartI->Directive);
814 }
815 
hasDirective(const llvm::function_ref<bool (OpenMPDirectiveKind,const DeclarationNameInfo &,SourceLocation)> & DPred,bool FromParent)816 bool DSAStackTy::hasDirective(
817     const llvm::function_ref<bool(OpenMPDirectiveKind,
818                                   const DeclarationNameInfo &, SourceLocation)>
819         &DPred,
820     bool FromParent) {
821   // We look only in the enclosing region.
822   if (Stack.size() < 2)
823     return false;
824   auto StartI = std::next(Stack.rbegin());
825   auto EndI = std::prev(Stack.rend());
826   if (FromParent && StartI != EndI) {
827     StartI = std::next(StartI);
828   }
829   for (auto I = StartI, EE = EndI; I != EE; ++I) {
830     if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc))
831       return true;
832   }
833   return false;
834 }
835 
InitDataSharingAttributesStack()836 void Sema::InitDataSharingAttributesStack() {
837   VarDataSharingAttributesStack = new DSAStackTy(*this);
838 }
839 
840 #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack)
841 
IsOpenMPCapturedByRef(ValueDecl * D,unsigned Level)842 bool Sema::IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level) {
843   assert(LangOpts.OpenMP && "OpenMP is not allowed");
844 
845   auto &Ctx = getASTContext();
846   bool IsByRef = true;
847 
848   // Find the directive that is associated with the provided scope.
849   auto Ty = D->getType();
850 
851   if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) {
852     // This table summarizes how a given variable should be passed to the device
853     // given its type and the clauses where it appears. This table is based on
854     // the description in OpenMP 4.5 [2.10.4, target Construct] and
855     // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses].
856     //
857     // =========================================================================
858     // | type |  defaultmap   | pvt | first | is_device_ptr |    map   | res.  |
859     // |      |(tofrom:scalar)|     |  pvt  |               |          |       |
860     // =========================================================================
861     // | scl  |               |     |       |       -       |          | bycopy|
862     // | scl  |               |  -  |   x   |       -       |     -    | bycopy|
863     // | scl  |               |  x  |   -   |       -       |     -    | null  |
864     // | scl  |       x       |     |       |       -       |          | byref |
865     // | scl  |       x       |  -  |   x   |       -       |     -    | bycopy|
866     // | scl  |       x       |  x  |   -   |       -       |     -    | null  |
867     // | scl  |               |  -  |   -   |       -       |     x    | byref |
868     // | scl  |       x       |  -  |   -   |       -       |     x    | byref |
869     //
870     // | agg  |      n.a.     |     |       |       -       |          | byref |
871     // | agg  |      n.a.     |  -  |   x   |       -       |     -    | byref |
872     // | agg  |      n.a.     |  x  |   -   |       -       |     -    | null  |
873     // | agg  |      n.a.     |  -  |   -   |       -       |     x    | byref |
874     // | agg  |      n.a.     |  -  |   -   |       -       |    x[]   | byref |
875     //
876     // | ptr  |      n.a.     |     |       |       -       |          | bycopy|
877     // | ptr  |      n.a.     |  -  |   x   |       -       |     -    | bycopy|
878     // | ptr  |      n.a.     |  x  |   -   |       -       |     -    | null  |
879     // | ptr  |      n.a.     |  -  |   -   |       -       |     x    | byref |
880     // | ptr  |      n.a.     |  -  |   -   |       -       |    x[]   | bycopy|
881     // | ptr  |      n.a.     |  -  |   -   |       x       |          | bycopy|
882     // | ptr  |      n.a.     |  -  |   -   |       x       |     x    | bycopy|
883     // | ptr  |      n.a.     |  -  |   -   |       x       |    x[]   | bycopy|
884     // =========================================================================
885     // Legend:
886     //  scl - scalar
887     //  ptr - pointer
888     //  agg - aggregate
889     //  x - applies
890     //  - - invalid in this combination
891     //  [] - mapped with an array section
892     //  byref - should be mapped by reference
893     //  byval - should be mapped by value
894     //  null - initialize a local variable to null on the device
895     //
896     // Observations:
897     //  - All scalar declarations that show up in a map clause have to be passed
898     //    by reference, because they may have been mapped in the enclosing data
899     //    environment.
900     //  - If the scalar value does not fit the size of uintptr, it has to be
901     //    passed by reference, regardless the result in the table above.
902     //  - For pointers mapped by value that have either an implicit map or an
903     //    array section, the runtime library may pass the NULL value to the
904     //    device instead of the value passed to it by the compiler.
905 
906 
907     if (Ty->isReferenceType())
908       Ty = Ty->castAs<ReferenceType>()->getPointeeType();
909 
910     // Locate map clauses and see if the variable being captured is referred to
911     // in any of those clauses. Here we only care about variables, not fields,
912     // because fields are part of aggregates.
913     bool IsVariableUsedInMapClause = false;
914     bool IsVariableAssociatedWithSection = false;
915 
916     DSAStack->checkMappableExprComponentListsForDecl(
917         D, /*CurrentRegionOnly=*/true,
918         [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
919                 MapExprComponents) {
920 
921           auto EI = MapExprComponents.rbegin();
922           auto EE = MapExprComponents.rend();
923 
924           assert(EI != EE && "Invalid map expression!");
925 
926           if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
927             IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
928 
929           ++EI;
930           if (EI == EE)
931             return false;
932 
933           if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
934               isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
935               isa<MemberExpr>(EI->getAssociatedExpression())) {
936             IsVariableAssociatedWithSection = true;
937             // There is nothing more we need to know about this variable.
938             return true;
939           }
940 
941           // Keep looking for more map info.
942           return false;
943         });
944 
945     if (IsVariableUsedInMapClause) {
946       // If variable is identified in a map clause it is always captured by
947       // reference except if it is a pointer that is dereferenced somehow.
948       IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
949     } else {
950       // By default, all the data that has a scalar type is mapped by copy.
951       IsByRef = !Ty->isScalarType();
952     }
953   }
954 
955   if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
956     IsByRef = !DSAStack->hasExplicitDSA(
957         D, [](OpenMPClauseKind K) -> bool { return K == OMPC_firstprivate; },
958         Level, /*NotLastprivate=*/true);
959   }
960 
961   // When passing data by copy, we need to make sure it fits the uintptr size
962   // and alignment, because the runtime library only deals with uintptr types.
963   // If it does not fit the uintptr size, we need to pass the data by reference
964   // instead.
965   if (!IsByRef &&
966       (Ctx.getTypeSizeInChars(Ty) >
967            Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
968        Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
969     IsByRef = true;
970   }
971 
972   return IsByRef;
973 }
974 
getOpenMPNestingLevel() const975 unsigned Sema::getOpenMPNestingLevel() const {
976   assert(getLangOpts().OpenMP);
977   return DSAStack->getNestingLevel();
978 }
979 
IsOpenMPCapturedDecl(ValueDecl * D)980 VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) {
981   assert(LangOpts.OpenMP && "OpenMP is not allowed");
982   D = getCanonicalDecl(D);
983 
984   // If we are attempting to capture a global variable in a directive with
985   // 'target' we return true so that this global is also mapped to the device.
986   //
987   // FIXME: If the declaration is enclosed in a 'declare target' directive,
988   // then it should not be captured. Therefore, an extra check has to be
989   // inserted here once support for 'declare target' is added.
990   //
991   auto *VD = dyn_cast<VarDecl>(D);
992   if (VD && !VD->hasLocalStorage()) {
993     if (DSAStack->getCurrentDirective() == OMPD_target &&
994         !DSAStack->isClauseParsingMode())
995       return VD;
996     if (DSAStack->hasDirective(
997             [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
998                SourceLocation) -> bool {
999               return isOpenMPTargetExecutionDirective(K);
1000             },
1001             false))
1002       return VD;
1003   }
1004 
1005   if (DSAStack->getCurrentDirective() != OMPD_unknown &&
1006       (!DSAStack->isClauseParsingMode() ||
1007        DSAStack->getParentDirective() != OMPD_unknown)) {
1008     auto &&Info = DSAStack->isLoopControlVariable(D);
1009     if (Info.first ||
1010         (VD && VD->hasLocalStorage() &&
1011          isParallelOrTaskRegion(DSAStack->getCurrentDirective())) ||
1012         (VD && DSAStack->isForceVarCapturing()))
1013       return VD ? VD : Info.second;
1014     auto DVarPrivate = DSAStack->getTopDSA(D, DSAStack->isClauseParsingMode());
1015     if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind))
1016       return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1017     DVarPrivate = DSAStack->hasDSA(
1018         D, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
1019         DSAStack->isClauseParsingMode());
1020     if (DVarPrivate.CKind != OMPC_unknown)
1021       return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1022   }
1023   return nullptr;
1024 }
1025 
isOpenMPPrivateDecl(ValueDecl * D,unsigned Level)1026 bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) {
1027   assert(LangOpts.OpenMP && "OpenMP is not allowed");
1028   return DSAStack->hasExplicitDSA(
1029       D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level);
1030 }
1031 
isOpenMPTargetCapturedDecl(ValueDecl * D,unsigned Level)1032 bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) {
1033   assert(LangOpts.OpenMP && "OpenMP is not allowed");
1034   // Return true if the current level is no longer enclosed in a target region.
1035 
1036   auto *VD = dyn_cast<VarDecl>(D);
1037   return VD && !VD->hasLocalStorage() &&
1038          DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
1039                                         Level);
1040 }
1041 
DestroyDataSharingAttributesStack()1042 void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; }
1043 
StartOpenMPDSABlock(OpenMPDirectiveKind DKind,const DeclarationNameInfo & DirName,Scope * CurScope,SourceLocation Loc)1044 void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
1045                                const DeclarationNameInfo &DirName,
1046                                Scope *CurScope, SourceLocation Loc) {
1047   DSAStack->push(DKind, DirName, CurScope, Loc);
1048   PushExpressionEvaluationContext(PotentiallyEvaluated);
1049 }
1050 
StartOpenMPClause(OpenMPClauseKind K)1051 void Sema::StartOpenMPClause(OpenMPClauseKind K) {
1052   DSAStack->setClauseParsingMode(K);
1053 }
1054 
EndOpenMPClause()1055 void Sema::EndOpenMPClause() {
1056   DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown);
1057 }
1058 
EndOpenMPDSABlock(Stmt * CurDirective)1059 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
1060   // OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
1061   //  A variable of class type (or array thereof) that appears in a lastprivate
1062   //  clause requires an accessible, unambiguous default constructor for the
1063   //  class type, unless the list item is also specified in a firstprivate
1064   //  clause.
1065   if (auto D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
1066     for (auto *C : D->clauses()) {
1067       if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
1068         SmallVector<Expr *, 8> PrivateCopies;
1069         for (auto *DE : Clause->varlists()) {
1070           if (DE->isValueDependent() || DE->isTypeDependent()) {
1071             PrivateCopies.push_back(nullptr);
1072             continue;
1073           }
1074           auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
1075           VarDecl *VD = cast<VarDecl>(DRE->getDecl());
1076           QualType Type = VD->getType().getNonReferenceType();
1077           auto DVar = DSAStack->getTopDSA(VD, false);
1078           if (DVar.CKind == OMPC_lastprivate) {
1079             // Generate helper private variable and initialize it with the
1080             // default value. The address of the original variable is replaced
1081             // by the address of the new private variable in CodeGen. This new
1082             // variable is not added to IdResolver, so the code in the OpenMP
1083             // region uses original variable for proper diagnostics.
1084             auto *VDPrivate = buildVarDecl(
1085                 *this, DE->getExprLoc(), Type.getUnqualifiedType(),
1086                 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr);
1087             ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false);
1088             if (VDPrivate->isInvalidDecl())
1089               continue;
1090             PrivateCopies.push_back(buildDeclRefExpr(
1091                 *this, VDPrivate, DE->getType(), DE->getExprLoc()));
1092           } else {
1093             // The variable is also a firstprivate, so initialization sequence
1094             // for private copy is generated already.
1095             PrivateCopies.push_back(nullptr);
1096           }
1097         }
1098         // Set initializers to private copies if no errors were found.
1099         if (PrivateCopies.size() == Clause->varlist_size())
1100           Clause->setPrivateCopies(PrivateCopies);
1101       }
1102     }
1103   }
1104 
1105   DSAStack->pop();
1106   DiscardCleanupsInEvaluationContext();
1107   PopExpressionEvaluationContext();
1108 }
1109 
1110 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1111                                      Expr *NumIterations, Sema &SemaRef,
1112                                      Scope *S, DSAStackTy *Stack);
1113 
1114 namespace {
1115 
1116 class VarDeclFilterCCC : public CorrectionCandidateCallback {
1117 private:
1118   Sema &SemaRef;
1119 
1120 public:
VarDeclFilterCCC(Sema & S)1121   explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
ValidateCandidate(const TypoCorrection & Candidate)1122   bool ValidateCandidate(const TypoCorrection &Candidate) override {
1123     NamedDecl *ND = Candidate.getCorrectionDecl();
1124     if (VarDecl *VD = dyn_cast_or_null<VarDecl>(ND)) {
1125       return VD->hasGlobalStorage() &&
1126              SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1127                                    SemaRef.getCurScope());
1128     }
1129     return false;
1130   }
1131 };
1132 
1133 class VarOrFuncDeclFilterCCC : public CorrectionCandidateCallback {
1134 private:
1135   Sema &SemaRef;
1136 
1137 public:
VarOrFuncDeclFilterCCC(Sema & S)1138   explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
ValidateCandidate(const TypoCorrection & Candidate)1139   bool ValidateCandidate(const TypoCorrection &Candidate) override {
1140     NamedDecl *ND = Candidate.getCorrectionDecl();
1141     if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
1142       return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1143                                    SemaRef.getCurScope());
1144     }
1145     return false;
1146   }
1147 };
1148 
1149 } // namespace
1150 
ActOnOpenMPIdExpression(Scope * CurScope,CXXScopeSpec & ScopeSpec,const DeclarationNameInfo & Id)1151 ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
1152                                          CXXScopeSpec &ScopeSpec,
1153                                          const DeclarationNameInfo &Id) {
1154   LookupResult Lookup(*this, Id, LookupOrdinaryName);
1155   LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
1156 
1157   if (Lookup.isAmbiguous())
1158     return ExprError();
1159 
1160   VarDecl *VD;
1161   if (!Lookup.isSingleResult()) {
1162     if (TypoCorrection Corrected = CorrectTypo(
1163             Id, LookupOrdinaryName, CurScope, nullptr,
1164             llvm::make_unique<VarDeclFilterCCC>(*this), CTK_ErrorRecovery)) {
1165       diagnoseTypo(Corrected,
1166                    PDiag(Lookup.empty()
1167                              ? diag::err_undeclared_var_use_suggest
1168                              : diag::err_omp_expected_var_arg_suggest)
1169                        << Id.getName());
1170       VD = Corrected.getCorrectionDeclAs<VarDecl>();
1171     } else {
1172       Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
1173                                        : diag::err_omp_expected_var_arg)
1174           << Id.getName();
1175       return ExprError();
1176     }
1177   } else {
1178     if (!(VD = Lookup.getAsSingle<VarDecl>())) {
1179       Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
1180       Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
1181       return ExprError();
1182     }
1183   }
1184   Lookup.suppressDiagnostics();
1185 
1186   // OpenMP [2.9.2, Syntax, C/C++]
1187   //   Variables must be file-scope, namespace-scope, or static block-scope.
1188   if (!VD->hasGlobalStorage()) {
1189     Diag(Id.getLoc(), diag::err_omp_global_var_arg)
1190         << getOpenMPDirectiveName(OMPD_threadprivate) << !VD->isStaticLocal();
1191     bool IsDecl =
1192         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1193     Diag(VD->getLocation(),
1194          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1195         << VD;
1196     return ExprError();
1197   }
1198 
1199   VarDecl *CanonicalVD = VD->getCanonicalDecl();
1200   NamedDecl *ND = cast<NamedDecl>(CanonicalVD);
1201   // OpenMP [2.9.2, Restrictions, C/C++, p.2]
1202   //   A threadprivate directive for file-scope variables must appear outside
1203   //   any definition or declaration.
1204   if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
1205       !getCurLexicalContext()->isTranslationUnit()) {
1206     Diag(Id.getLoc(), diag::err_omp_var_scope)
1207         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1208     bool IsDecl =
1209         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1210     Diag(VD->getLocation(),
1211          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1212         << VD;
1213     return ExprError();
1214   }
1215   // OpenMP [2.9.2, Restrictions, C/C++, p.3]
1216   //   A threadprivate directive for static class member variables must appear
1217   //   in the class definition, in the same scope in which the member
1218   //   variables are declared.
1219   if (CanonicalVD->isStaticDataMember() &&
1220       !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
1221     Diag(Id.getLoc(), diag::err_omp_var_scope)
1222         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1223     bool IsDecl =
1224         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1225     Diag(VD->getLocation(),
1226          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1227         << VD;
1228     return ExprError();
1229   }
1230   // OpenMP [2.9.2, Restrictions, C/C++, p.4]
1231   //   A threadprivate directive for namespace-scope variables must appear
1232   //   outside any definition or declaration other than the namespace
1233   //   definition itself.
1234   if (CanonicalVD->getDeclContext()->isNamespace() &&
1235       (!getCurLexicalContext()->isFileContext() ||
1236        !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
1237     Diag(Id.getLoc(), diag::err_omp_var_scope)
1238         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1239     bool IsDecl =
1240         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1241     Diag(VD->getLocation(),
1242          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1243         << VD;
1244     return ExprError();
1245   }
1246   // OpenMP [2.9.2, Restrictions, C/C++, p.6]
1247   //   A threadprivate directive for static block-scope variables must appear
1248   //   in the scope of the variable and not in a nested scope.
1249   if (CanonicalVD->isStaticLocal() && CurScope &&
1250       !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
1251     Diag(Id.getLoc(), diag::err_omp_var_scope)
1252         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1253     bool IsDecl =
1254         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1255     Diag(VD->getLocation(),
1256          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1257         << VD;
1258     return ExprError();
1259   }
1260 
1261   // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
1262   //   A threadprivate directive must lexically precede all references to any
1263   //   of the variables in its list.
1264   if (VD->isUsed() && !DSAStack->isThreadPrivate(VD)) {
1265     Diag(Id.getLoc(), diag::err_omp_var_used)
1266         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1267     return ExprError();
1268   }
1269 
1270   QualType ExprType = VD->getType().getNonReferenceType();
1271   return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
1272                              SourceLocation(), VD,
1273                              /*RefersToEnclosingVariableOrCapture=*/false,
1274                              Id.getLoc(), ExprType, VK_LValue);
1275 }
1276 
1277 Sema::DeclGroupPtrTy
ActOnOpenMPThreadprivateDirective(SourceLocation Loc,ArrayRef<Expr * > VarList)1278 Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
1279                                         ArrayRef<Expr *> VarList) {
1280   if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
1281     CurContext->addDecl(D);
1282     return DeclGroupPtrTy::make(DeclGroupRef(D));
1283   }
1284   return nullptr;
1285 }
1286 
1287 namespace {
1288 class LocalVarRefChecker : public ConstStmtVisitor<LocalVarRefChecker, bool> {
1289   Sema &SemaRef;
1290 
1291 public:
VisitDeclRefExpr(const DeclRefExpr * E)1292   bool VisitDeclRefExpr(const DeclRefExpr *E) {
1293     if (auto VD = dyn_cast<VarDecl>(E->getDecl())) {
1294       if (VD->hasLocalStorage()) {
1295         SemaRef.Diag(E->getLocStart(),
1296                      diag::err_omp_local_var_in_threadprivate_init)
1297             << E->getSourceRange();
1298         SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
1299             << VD << VD->getSourceRange();
1300         return true;
1301       }
1302     }
1303     return false;
1304   }
VisitStmt(const Stmt * S)1305   bool VisitStmt(const Stmt *S) {
1306     for (auto Child : S->children()) {
1307       if (Child && Visit(Child))
1308         return true;
1309     }
1310     return false;
1311   }
LocalVarRefChecker(Sema & SemaRef)1312   explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
1313 };
1314 } // namespace
1315 
1316 OMPThreadPrivateDecl *
CheckOMPThreadPrivateDecl(SourceLocation Loc,ArrayRef<Expr * > VarList)1317 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
1318   SmallVector<Expr *, 8> Vars;
1319   for (auto &RefExpr : VarList) {
1320     DeclRefExpr *DE = cast<DeclRefExpr>(RefExpr);
1321     VarDecl *VD = cast<VarDecl>(DE->getDecl());
1322     SourceLocation ILoc = DE->getExprLoc();
1323 
1324     // Mark variable as used.
1325     VD->setReferenced();
1326     VD->markUsed(Context);
1327 
1328     QualType QType = VD->getType();
1329     if (QType->isDependentType() || QType->isInstantiationDependentType()) {
1330       // It will be analyzed later.
1331       Vars.push_back(DE);
1332       continue;
1333     }
1334 
1335     // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1336     //   A threadprivate variable must not have an incomplete type.
1337     if (RequireCompleteType(ILoc, VD->getType(),
1338                             diag::err_omp_threadprivate_incomplete_type)) {
1339       continue;
1340     }
1341 
1342     // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1343     //   A threadprivate variable must not have a reference type.
1344     if (VD->getType()->isReferenceType()) {
1345       Diag(ILoc, diag::err_omp_ref_type_arg)
1346           << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
1347       bool IsDecl =
1348           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1349       Diag(VD->getLocation(),
1350            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1351           << VD;
1352       continue;
1353     }
1354 
1355     // Check if this is a TLS variable. If TLS is not being supported, produce
1356     // the corresponding diagnostic.
1357     if ((VD->getTLSKind() != VarDecl::TLS_None &&
1358          !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
1359            getLangOpts().OpenMPUseTLS &&
1360            getASTContext().getTargetInfo().isTLSSupported())) ||
1361         (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
1362          !VD->isLocalVarDecl())) {
1363       Diag(ILoc, diag::err_omp_var_thread_local)
1364           << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
1365       bool IsDecl =
1366           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1367       Diag(VD->getLocation(),
1368            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1369           << VD;
1370       continue;
1371     }
1372 
1373     // Check if initial value of threadprivate variable reference variable with
1374     // local storage (it is not supported by runtime).
1375     if (auto Init = VD->getAnyInitializer()) {
1376       LocalVarRefChecker Checker(*this);
1377       if (Checker.Visit(Init))
1378         continue;
1379     }
1380 
1381     Vars.push_back(RefExpr);
1382     DSAStack->addDSA(VD, DE, OMPC_threadprivate);
1383     VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
1384         Context, SourceRange(Loc, Loc)));
1385     if (auto *ML = Context.getASTMutationListener())
1386       ML->DeclarationMarkedOpenMPThreadPrivate(VD);
1387   }
1388   OMPThreadPrivateDecl *D = nullptr;
1389   if (!Vars.empty()) {
1390     D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
1391                                      Vars);
1392     D->setAccess(AS_public);
1393   }
1394   return D;
1395 }
1396 
ReportOriginalDSA(Sema & SemaRef,DSAStackTy * Stack,const ValueDecl * D,DSAStackTy::DSAVarData DVar,bool IsLoopIterVar=false)1397 static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack,
1398                               const ValueDecl *D, DSAStackTy::DSAVarData DVar,
1399                               bool IsLoopIterVar = false) {
1400   if (DVar.RefExpr) {
1401     SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
1402         << getOpenMPClauseName(DVar.CKind);
1403     return;
1404   }
1405   enum {
1406     PDSA_StaticMemberShared,
1407     PDSA_StaticLocalVarShared,
1408     PDSA_LoopIterVarPrivate,
1409     PDSA_LoopIterVarLinear,
1410     PDSA_LoopIterVarLastprivate,
1411     PDSA_ConstVarShared,
1412     PDSA_GlobalVarShared,
1413     PDSA_TaskVarFirstprivate,
1414     PDSA_LocalVarPrivate,
1415     PDSA_Implicit
1416   } Reason = PDSA_Implicit;
1417   bool ReportHint = false;
1418   auto ReportLoc = D->getLocation();
1419   auto *VD = dyn_cast<VarDecl>(D);
1420   if (IsLoopIterVar) {
1421     if (DVar.CKind == OMPC_private)
1422       Reason = PDSA_LoopIterVarPrivate;
1423     else if (DVar.CKind == OMPC_lastprivate)
1424       Reason = PDSA_LoopIterVarLastprivate;
1425     else
1426       Reason = PDSA_LoopIterVarLinear;
1427   } else if (isOpenMPTaskingDirective(DVar.DKind) &&
1428              DVar.CKind == OMPC_firstprivate) {
1429     Reason = PDSA_TaskVarFirstprivate;
1430     ReportLoc = DVar.ImplicitDSALoc;
1431   } else if (VD && VD->isStaticLocal())
1432     Reason = PDSA_StaticLocalVarShared;
1433   else if (VD && VD->isStaticDataMember())
1434     Reason = PDSA_StaticMemberShared;
1435   else if (VD && VD->isFileVarDecl())
1436     Reason = PDSA_GlobalVarShared;
1437   else if (D->getType().isConstant(SemaRef.getASTContext()))
1438     Reason = PDSA_ConstVarShared;
1439   else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
1440     ReportHint = true;
1441     Reason = PDSA_LocalVarPrivate;
1442   }
1443   if (Reason != PDSA_Implicit) {
1444     SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
1445         << Reason << ReportHint
1446         << getOpenMPDirectiveName(Stack->getCurrentDirective());
1447   } else if (DVar.ImplicitDSALoc.isValid()) {
1448     SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
1449         << getOpenMPClauseName(DVar.CKind);
1450   }
1451 }
1452 
1453 namespace {
1454 class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> {
1455   DSAStackTy *Stack;
1456   Sema &SemaRef;
1457   bool ErrorFound;
1458   CapturedStmt *CS;
1459   llvm::SmallVector<Expr *, 8> ImplicitFirstprivate;
1460   llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
1461 
1462 public:
VisitDeclRefExpr(DeclRefExpr * E)1463   void VisitDeclRefExpr(DeclRefExpr *E) {
1464     if (E->isTypeDependent() || E->isValueDependent() ||
1465         E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1466       return;
1467     if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1468       // Skip internally declared variables.
1469       if (VD->isLocalVarDecl() && !CS->capturesVariable(VD))
1470         return;
1471 
1472       auto DVar = Stack->getTopDSA(VD, false);
1473       // Check if the variable has explicit DSA set and stop analysis if it so.
1474       if (DVar.RefExpr) return;
1475 
1476       auto ELoc = E->getExprLoc();
1477       auto DKind = Stack->getCurrentDirective();
1478       // The default(none) clause requires that each variable that is referenced
1479       // in the construct, and does not have a predetermined data-sharing
1480       // attribute, must have its data-sharing attribute explicitly determined
1481       // by being listed in a data-sharing attribute clause.
1482       if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none &&
1483           isParallelOrTaskRegion(DKind) &&
1484           VarsWithInheritedDSA.count(VD) == 0) {
1485         VarsWithInheritedDSA[VD] = E;
1486         return;
1487       }
1488 
1489       // OpenMP [2.9.3.6, Restrictions, p.2]
1490       //  A list item that appears in a reduction clause of the innermost
1491       //  enclosing worksharing or parallel construct may not be accessed in an
1492       //  explicit task.
1493       DVar = Stack->hasInnermostDSA(
1494           VD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1495           [](OpenMPDirectiveKind K) -> bool {
1496             return isOpenMPParallelDirective(K) ||
1497                    isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
1498           },
1499           false);
1500       if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1501         ErrorFound = true;
1502         SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1503         ReportOriginalDSA(SemaRef, Stack, VD, DVar);
1504         return;
1505       }
1506 
1507       // Define implicit data-sharing attributes for task.
1508       DVar = Stack->getImplicitDSA(VD, false);
1509       if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1510           !Stack->isLoopControlVariable(VD).first)
1511         ImplicitFirstprivate.push_back(E);
1512     }
1513   }
VisitMemberExpr(MemberExpr * E)1514   void VisitMemberExpr(MemberExpr *E) {
1515     if (E->isTypeDependent() || E->isValueDependent() ||
1516         E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1517       return;
1518     if (isa<CXXThisExpr>(E->getBase()->IgnoreParens())) {
1519       if (auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
1520         auto DVar = Stack->getTopDSA(FD, false);
1521         // Check if the variable has explicit DSA set and stop analysis if it
1522         // so.
1523         if (DVar.RefExpr)
1524           return;
1525 
1526         auto ELoc = E->getExprLoc();
1527         auto DKind = Stack->getCurrentDirective();
1528         // OpenMP [2.9.3.6, Restrictions, p.2]
1529         //  A list item that appears in a reduction clause of the innermost
1530         //  enclosing worksharing or parallel construct may not be accessed in
1531         //  an  explicit task.
1532         DVar = Stack->hasInnermostDSA(
1533             FD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1534             [](OpenMPDirectiveKind K) -> bool {
1535               return isOpenMPParallelDirective(K) ||
1536                      isOpenMPWorksharingDirective(K) ||
1537                      isOpenMPTeamsDirective(K);
1538             },
1539             false);
1540         if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1541           ErrorFound = true;
1542           SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1543           ReportOriginalDSA(SemaRef, Stack, FD, DVar);
1544           return;
1545         }
1546 
1547         // Define implicit data-sharing attributes for task.
1548         DVar = Stack->getImplicitDSA(FD, false);
1549         if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1550             !Stack->isLoopControlVariable(FD).first)
1551           ImplicitFirstprivate.push_back(E);
1552       }
1553     }
1554   }
VisitOMPExecutableDirective(OMPExecutableDirective * S)1555   void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
1556     for (auto *C : S->clauses()) {
1557       // Skip analysis of arguments of implicitly defined firstprivate clause
1558       // for task directives.
1559       if (C && (!isa<OMPFirstprivateClause>(C) || C->getLocStart().isValid()))
1560         for (auto *CC : C->children()) {
1561           if (CC)
1562             Visit(CC);
1563         }
1564     }
1565   }
VisitStmt(Stmt * S)1566   void VisitStmt(Stmt *S) {
1567     for (auto *C : S->children()) {
1568       if (C && !isa<OMPExecutableDirective>(C))
1569         Visit(C);
1570     }
1571   }
1572 
isErrorFound()1573   bool isErrorFound() { return ErrorFound; }
getImplicitFirstprivate()1574   ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; }
getVarsWithInheritedDSA()1575   llvm::DenseMap<ValueDecl *, Expr *> &getVarsWithInheritedDSA() {
1576     return VarsWithInheritedDSA;
1577   }
1578 
DSAAttrChecker(DSAStackTy * S,Sema & SemaRef,CapturedStmt * CS)1579   DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
1580       : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {}
1581 };
1582 } // namespace
1583 
ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind,Scope * CurScope)1584 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
1585   switch (DKind) {
1586   case OMPD_parallel:
1587   case OMPD_parallel_for:
1588   case OMPD_parallel_for_simd:
1589   case OMPD_parallel_sections:
1590   case OMPD_teams: {
1591     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1592     QualType KmpInt32PtrTy =
1593         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1594     Sema::CapturedParamNameType Params[] = {
1595         std::make_pair(".global_tid.", KmpInt32PtrTy),
1596         std::make_pair(".bound_tid.", KmpInt32PtrTy),
1597         std::make_pair(StringRef(), QualType()) // __context with shared vars
1598     };
1599     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1600                              Params);
1601     break;
1602   }
1603   case OMPD_simd:
1604   case OMPD_for:
1605   case OMPD_for_simd:
1606   case OMPD_sections:
1607   case OMPD_section:
1608   case OMPD_single:
1609   case OMPD_master:
1610   case OMPD_critical:
1611   case OMPD_taskgroup:
1612   case OMPD_distribute:
1613   case OMPD_ordered:
1614   case OMPD_atomic:
1615   case OMPD_target_data:
1616   case OMPD_target:
1617   case OMPD_target_parallel:
1618   case OMPD_target_parallel_for:
1619   case OMPD_target_parallel_for_simd: {
1620     Sema::CapturedParamNameType Params[] = {
1621         std::make_pair(StringRef(), QualType()) // __context with shared vars
1622     };
1623     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1624                              Params);
1625     break;
1626   }
1627   case OMPD_task: {
1628     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1629     QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1630     FunctionProtoType::ExtProtoInfo EPI;
1631     EPI.Variadic = true;
1632     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1633     Sema::CapturedParamNameType Params[] = {
1634         std::make_pair(".global_tid.", KmpInt32Ty),
1635         std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1636         std::make_pair(".privates.", Context.VoidPtrTy.withConst()),
1637         std::make_pair(".copy_fn.",
1638                        Context.getPointerType(CopyFnType).withConst()),
1639         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1640         std::make_pair(StringRef(), QualType()) // __context with shared vars
1641     };
1642     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1643                              Params);
1644     // Mark this captured region as inlined, because we don't use outlined
1645     // function directly.
1646     getCurCapturedRegion()->TheCapturedDecl->addAttr(
1647         AlwaysInlineAttr::CreateImplicit(
1648             Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1649     break;
1650   }
1651   case OMPD_taskloop:
1652   case OMPD_taskloop_simd: {
1653     QualType KmpInt32Ty =
1654         Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
1655     QualType KmpUInt64Ty =
1656         Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
1657     QualType KmpInt64Ty =
1658         Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
1659     QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1660     FunctionProtoType::ExtProtoInfo EPI;
1661     EPI.Variadic = true;
1662     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1663     Sema::CapturedParamNameType Params[] = {
1664         std::make_pair(".global_tid.", KmpInt32Ty),
1665         std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1666         std::make_pair(".privates.",
1667                        Context.VoidPtrTy.withConst().withRestrict()),
1668         std::make_pair(
1669             ".copy_fn.",
1670             Context.getPointerType(CopyFnType).withConst().withRestrict()),
1671         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1672         std::make_pair(".lb.", KmpUInt64Ty),
1673         std::make_pair(".ub.", KmpUInt64Ty), std::make_pair(".st.", KmpInt64Ty),
1674         std::make_pair(".liter.", KmpInt32Ty),
1675         std::make_pair(StringRef(), QualType()) // __context with shared vars
1676     };
1677     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1678                              Params);
1679     // Mark this captured region as inlined, because we don't use outlined
1680     // function directly.
1681     getCurCapturedRegion()->TheCapturedDecl->addAttr(
1682         AlwaysInlineAttr::CreateImplicit(
1683             Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1684     break;
1685   }
1686   case OMPD_distribute_parallel_for_simd:
1687   case OMPD_distribute_simd:
1688   case OMPD_distribute_parallel_for: {
1689     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1690     QualType KmpInt32PtrTy =
1691         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1692     Sema::CapturedParamNameType Params[] = {
1693         std::make_pair(".global_tid.", KmpInt32PtrTy),
1694         std::make_pair(".bound_tid.", KmpInt32PtrTy),
1695         std::make_pair(".previous.lb.", Context.getSizeType()),
1696         std::make_pair(".previous.ub.", Context.getSizeType()),
1697         std::make_pair(StringRef(), QualType()) // __context with shared vars
1698     };
1699     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1700                              Params);
1701     break;
1702   }
1703   case OMPD_threadprivate:
1704   case OMPD_taskyield:
1705   case OMPD_barrier:
1706   case OMPD_taskwait:
1707   case OMPD_cancellation_point:
1708   case OMPD_cancel:
1709   case OMPD_flush:
1710   case OMPD_target_enter_data:
1711   case OMPD_target_exit_data:
1712   case OMPD_declare_reduction:
1713   case OMPD_declare_simd:
1714   case OMPD_declare_target:
1715   case OMPD_end_declare_target:
1716   case OMPD_target_update:
1717     llvm_unreachable("OpenMP Directive is not allowed");
1718   case OMPD_unknown:
1719     llvm_unreachable("Unknown OpenMP directive");
1720   }
1721 }
1722 
buildCaptureDecl(Sema & S,IdentifierInfo * Id,Expr * CaptureExpr,bool WithInit,bool AsExpression)1723 static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id,
1724                                              Expr *CaptureExpr, bool WithInit,
1725                                              bool AsExpression) {
1726   assert(CaptureExpr);
1727   ASTContext &C = S.getASTContext();
1728   Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
1729   QualType Ty = Init->getType();
1730   if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) {
1731     if (S.getLangOpts().CPlusPlus)
1732       Ty = C.getLValueReferenceType(Ty);
1733     else {
1734       Ty = C.getPointerType(Ty);
1735       ExprResult Res =
1736           S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init);
1737       if (!Res.isUsable())
1738         return nullptr;
1739       Init = Res.get();
1740     }
1741     WithInit = true;
1742   }
1743   auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty);
1744   if (!WithInit)
1745     CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C, SourceRange()));
1746   S.CurContext->addHiddenDecl(CED);
1747   S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false,
1748                          /*TypeMayContainAuto=*/true);
1749   return CED;
1750 }
1751 
buildCapture(Sema & S,ValueDecl * D,Expr * CaptureExpr,bool WithInit)1752 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
1753                                  bool WithInit) {
1754   OMPCapturedExprDecl *CD;
1755   if (auto *VD = S.IsOpenMPCapturedDecl(D))
1756     CD = cast<OMPCapturedExprDecl>(VD);
1757   else
1758     CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit,
1759                           /*AsExpression=*/false);
1760   return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1761                           CaptureExpr->getExprLoc());
1762 }
1763 
buildCapture(Sema & S,Expr * CaptureExpr,DeclRefExpr * & Ref)1764 static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) {
1765   if (!Ref) {
1766     auto *CD =
1767         buildCaptureDecl(S, &S.getASTContext().Idents.get(".capture_expr."),
1768                          CaptureExpr, /*WithInit=*/true, /*AsExpression=*/true);
1769     Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1770                            CaptureExpr->getExprLoc());
1771   }
1772   ExprResult Res = Ref;
1773   if (!S.getLangOpts().CPlusPlus &&
1774       CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() &&
1775       Ref->getType()->isPointerType())
1776     Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref);
1777   if (!Res.isUsable())
1778     return ExprError();
1779   return CaptureExpr->isGLValue() ? Res : S.DefaultLvalueConversion(Res.get());
1780 }
1781 
ActOnOpenMPRegionEnd(StmtResult S,ArrayRef<OMPClause * > Clauses)1782 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
1783                                       ArrayRef<OMPClause *> Clauses) {
1784   if (!S.isUsable()) {
1785     ActOnCapturedRegionError();
1786     return StmtError();
1787   }
1788 
1789   OMPOrderedClause *OC = nullptr;
1790   OMPScheduleClause *SC = nullptr;
1791   SmallVector<OMPLinearClause *, 4> LCs;
1792   // This is required for proper codegen.
1793   for (auto *Clause : Clauses) {
1794     if (isOpenMPPrivate(Clause->getClauseKind()) ||
1795         Clause->getClauseKind() == OMPC_copyprivate ||
1796         (getLangOpts().OpenMPUseTLS &&
1797          getASTContext().getTargetInfo().isTLSSupported() &&
1798          Clause->getClauseKind() == OMPC_copyin)) {
1799       DSAStack->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin);
1800       // Mark all variables in private list clauses as used in inner region.
1801       for (auto *VarRef : Clause->children()) {
1802         if (auto *E = cast_or_null<Expr>(VarRef)) {
1803           MarkDeclarationsReferencedInExpr(E);
1804         }
1805       }
1806       DSAStack->setForceVarCapturing(/*V=*/false);
1807     } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective())) {
1808       // Mark all variables in private list clauses as used in inner region.
1809       // Required for proper codegen of combined directives.
1810       // TODO: add processing for other clauses.
1811       if (auto *C = OMPClauseWithPreInit::get(Clause)) {
1812         if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
1813           for (auto *D : DS->decls())
1814             MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
1815         }
1816       }
1817       if (auto *C = OMPClauseWithPostUpdate::get(Clause)) {
1818         if (auto *E = C->getPostUpdateExpr())
1819           MarkDeclarationsReferencedInExpr(E);
1820       }
1821     }
1822     if (Clause->getClauseKind() == OMPC_schedule)
1823       SC = cast<OMPScheduleClause>(Clause);
1824     else if (Clause->getClauseKind() == OMPC_ordered)
1825       OC = cast<OMPOrderedClause>(Clause);
1826     else if (Clause->getClauseKind() == OMPC_linear)
1827       LCs.push_back(cast<OMPLinearClause>(Clause));
1828   }
1829   bool ErrorFound = false;
1830   // OpenMP, 2.7.1 Loop Construct, Restrictions
1831   // The nonmonotonic modifier cannot be specified if an ordered clause is
1832   // specified.
1833   if (SC &&
1834       (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
1835        SC->getSecondScheduleModifier() ==
1836            OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
1837       OC) {
1838     Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
1839              ? SC->getFirstScheduleModifierLoc()
1840              : SC->getSecondScheduleModifierLoc(),
1841          diag::err_omp_schedule_nonmonotonic_ordered)
1842         << SourceRange(OC->getLocStart(), OC->getLocEnd());
1843     ErrorFound = true;
1844   }
1845   if (!LCs.empty() && OC && OC->getNumForLoops()) {
1846     for (auto *C : LCs) {
1847       Diag(C->getLocStart(), diag::err_omp_linear_ordered)
1848           << SourceRange(OC->getLocStart(), OC->getLocEnd());
1849     }
1850     ErrorFound = true;
1851   }
1852   if (isOpenMPWorksharingDirective(DSAStack->getCurrentDirective()) &&
1853       isOpenMPSimdDirective(DSAStack->getCurrentDirective()) && OC &&
1854       OC->getNumForLoops()) {
1855     Diag(OC->getLocStart(), diag::err_omp_ordered_simd)
1856         << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
1857     ErrorFound = true;
1858   }
1859   if (ErrorFound) {
1860     ActOnCapturedRegionError();
1861     return StmtError();
1862   }
1863   return ActOnCapturedRegionEnd(S.get());
1864 }
1865 
CheckNestingOfRegions(Sema & SemaRef,DSAStackTy * Stack,OpenMPDirectiveKind CurrentRegion,const DeclarationNameInfo & CurrentName,OpenMPDirectiveKind CancelRegion,SourceLocation StartLoc)1866 static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack,
1867                                   OpenMPDirectiveKind CurrentRegion,
1868                                   const DeclarationNameInfo &CurrentName,
1869                                   OpenMPDirectiveKind CancelRegion,
1870                                   SourceLocation StartLoc) {
1871   // Allowed nesting of constructs
1872   // +------------------+-----------------+------------------------------------+
1873   // | Parent directive | Child directive | Closely (!), No-Closely(+), Both(*)|
1874   // +------------------+-----------------+------------------------------------+
1875   // | parallel         | parallel        | *                                  |
1876   // | parallel         | for             | *                                  |
1877   // | parallel         | for simd        | *                                  |
1878   // | parallel         | master          | *                                  |
1879   // | parallel         | critical        | *                                  |
1880   // | parallel         | simd            | *                                  |
1881   // | parallel         | sections        | *                                  |
1882   // | parallel         | section         | +                                  |
1883   // | parallel         | single          | *                                  |
1884   // | parallel         | parallel for    | *                                  |
1885   // | parallel         |parallel for simd| *                                  |
1886   // | parallel         |parallel sections| *                                  |
1887   // | parallel         | task            | *                                  |
1888   // | parallel         | taskyield       | *                                  |
1889   // | parallel         | barrier         | *                                  |
1890   // | parallel         | taskwait        | *                                  |
1891   // | parallel         | taskgroup       | *                                  |
1892   // | parallel         | flush           | *                                  |
1893   // | parallel         | ordered         | +                                  |
1894   // | parallel         | atomic          | *                                  |
1895   // | parallel         | target          | *                                  |
1896   // | parallel         | target parallel | *                                  |
1897   // | parallel         | target parallel | *                                  |
1898   // |                  | for             |                                    |
1899   // | parallel         | target enter    | *                                  |
1900   // |                  | data            |                                    |
1901   // | parallel         | target exit     | *                                  |
1902   // |                  | data            |                                    |
1903   // | parallel         | teams           | +                                  |
1904   // | parallel         | cancellation    |                                    |
1905   // |                  | point           | !                                  |
1906   // | parallel         | cancel          | !                                  |
1907   // | parallel         | taskloop        | *                                  |
1908   // | parallel         | taskloop simd   | *                                  |
1909   // | parallel         | distribute      | +                                  |
1910   // | parallel         | distribute      | +                                  |
1911   // |                  | parallel for    |                                    |
1912   // | parallel         | distribute      | +                                  |
1913   // |                  |parallel for simd|                                    |
1914   // | parallel         | distribute simd | +                                  |
1915   // +------------------+-----------------+------------------------------------+
1916   // | for              | parallel        | *                                  |
1917   // | for              | for             | +                                  |
1918   // | for              | for simd        | +                                  |
1919   // | for              | master          | +                                  |
1920   // | for              | critical        | *                                  |
1921   // | for              | simd            | *                                  |
1922   // | for              | sections        | +                                  |
1923   // | for              | section         | +                                  |
1924   // | for              | single          | +                                  |
1925   // | for              | parallel for    | *                                  |
1926   // | for              |parallel for simd| *                                  |
1927   // | for              |parallel sections| *                                  |
1928   // | for              | task            | *                                  |
1929   // | for              | taskyield       | *                                  |
1930   // | for              | barrier         | +                                  |
1931   // | for              | taskwait        | *                                  |
1932   // | for              | taskgroup       | *                                  |
1933   // | for              | flush           | *                                  |
1934   // | for              | ordered         | * (if construct is ordered)        |
1935   // | for              | atomic          | *                                  |
1936   // | for              | target          | *                                  |
1937   // | for              | target parallel | *                                  |
1938   // | for              | target parallel | *                                  |
1939   // |                  | for             |                                    |
1940   // | for              | target enter    | *                                  |
1941   // |                  | data            |                                    |
1942   // | for              | target exit     | *                                  |
1943   // |                  | data            |                                    |
1944   // | for              | teams           | +                                  |
1945   // | for              | cancellation    |                                    |
1946   // |                  | point           | !                                  |
1947   // | for              | cancel          | !                                  |
1948   // | for              | taskloop        | *                                  |
1949   // | for              | taskloop simd   | *                                  |
1950   // | for              | distribute      | +                                  |
1951   // | for              | distribute      | +                                  |
1952   // |                  | parallel for    |                                    |
1953   // | for              | distribute      | +                                  |
1954   // |                  |parallel for simd|                                    |
1955   // | for              | distribute simd | +                                  |
1956   // | for              | target parallel | +                                  |
1957   // |                  | for simd        |                                    |
1958   // +------------------+-----------------+------------------------------------+
1959   // | master           | parallel        | *                                  |
1960   // | master           | for             | +                                  |
1961   // | master           | for simd        | +                                  |
1962   // | master           | master          | *                                  |
1963   // | master           | critical        | *                                  |
1964   // | master           | simd            | *                                  |
1965   // | master           | sections        | +                                  |
1966   // | master           | section         | +                                  |
1967   // | master           | single          | +                                  |
1968   // | master           | parallel for    | *                                  |
1969   // | master           |parallel for simd| *                                  |
1970   // | master           |parallel sections| *                                  |
1971   // | master           | task            | *                                  |
1972   // | master           | taskyield       | *                                  |
1973   // | master           | barrier         | +                                  |
1974   // | master           | taskwait        | *                                  |
1975   // | master           | taskgroup       | *                                  |
1976   // | master           | flush           | *                                  |
1977   // | master           | ordered         | +                                  |
1978   // | master           | atomic          | *                                  |
1979   // | master           | target          | *                                  |
1980   // | master           | target parallel | *                                  |
1981   // | master           | target parallel | *                                  |
1982   // |                  | for             |                                    |
1983   // | master           | target enter    | *                                  |
1984   // |                  | data            |                                    |
1985   // | master           | target exit     | *                                  |
1986   // |                  | data            |                                    |
1987   // | master           | teams           | +                                  |
1988   // | master           | cancellation    |                                    |
1989   // |                  | point           |                                    |
1990   // | master           | cancel          |                                    |
1991   // | master           | taskloop        | *                                  |
1992   // | master           | taskloop simd   | *                                  |
1993   // | master           | distribute      | +                                  |
1994   // | master           | distribute      | +                                  |
1995   // |                  | parallel for    |                                    |
1996   // | master           | distribute      | +                                  |
1997   // |                  |parallel for simd|                                    |
1998   // | master           | distribute simd | +                                  |
1999   // | master           | target parallel | +                                  |
2000   // |                  | for simd        |                                    |
2001   // +------------------+-----------------+------------------------------------+
2002   // | critical         | parallel        | *                                  |
2003   // | critical         | for             | +                                  |
2004   // | critical         | for simd        | +                                  |
2005   // | critical         | master          | *                                  |
2006   // | critical         | critical        | * (should have different names)    |
2007   // | critical         | simd            | *                                  |
2008   // | critical         | sections        | +                                  |
2009   // | critical         | section         | +                                  |
2010   // | critical         | single          | +                                  |
2011   // | critical         | parallel for    | *                                  |
2012   // | critical         |parallel for simd| *                                  |
2013   // | critical         |parallel sections| *                                  |
2014   // | critical         | task            | *                                  |
2015   // | critical         | taskyield       | *                                  |
2016   // | critical         | barrier         | +                                  |
2017   // | critical         | taskwait        | *                                  |
2018   // | critical         | taskgroup       | *                                  |
2019   // | critical         | ordered         | +                                  |
2020   // | critical         | atomic          | *                                  |
2021   // | critical         | target          | *                                  |
2022   // | critical         | target parallel | *                                  |
2023   // | critical         | target parallel | *                                  |
2024   // |                  | for             |                                    |
2025   // | critical         | target enter    | *                                  |
2026   // |                  | data            |                                    |
2027   // | critical         | target exit     | *                                  |
2028   // |                  | data            |                                    |
2029   // | critical         | teams           | +                                  |
2030   // | critical         | cancellation    |                                    |
2031   // |                  | point           |                                    |
2032   // | critical         | cancel          |                                    |
2033   // | critical         | taskloop        | *                                  |
2034   // | critical         | taskloop simd   | *                                  |
2035   // | critical         | distribute      | +                                  |
2036   // | critical         | distribute      | +                                  |
2037   // |                  | parallel for    |                                    |
2038   // | critical         | distribute      | +                                  |
2039   // |                  |parallel for simd|                                    |
2040   // | critical         | distribute simd | +                                  |
2041   // | critical         | target parallel | +                                  |
2042   // |                  | for simd        |                                    |
2043   // +------------------+-----------------+------------------------------------+
2044   // | simd             | parallel        |                                    |
2045   // | simd             | for             |                                    |
2046   // | simd             | for simd        |                                    |
2047   // | simd             | master          |                                    |
2048   // | simd             | critical        |                                    |
2049   // | simd             | simd            | *                                  |
2050   // | simd             | sections        |                                    |
2051   // | simd             | section         |                                    |
2052   // | simd             | single          |                                    |
2053   // | simd             | parallel for    |                                    |
2054   // | simd             |parallel for simd|                                    |
2055   // | simd             |parallel sections|                                    |
2056   // | simd             | task            |                                    |
2057   // | simd             | taskyield       |                                    |
2058   // | simd             | barrier         |                                    |
2059   // | simd             | taskwait        |                                    |
2060   // | simd             | taskgroup       |                                    |
2061   // | simd             | flush           |                                    |
2062   // | simd             | ordered         | + (with simd clause)               |
2063   // | simd             | atomic          |                                    |
2064   // | simd             | target          |                                    |
2065   // | simd             | target parallel |                                    |
2066   // | simd             | target parallel |                                    |
2067   // |                  | for             |                                    |
2068   // | simd             | target enter    |                                    |
2069   // |                  | data            |                                    |
2070   // | simd             | target exit     |                                    |
2071   // |                  | data            |                                    |
2072   // | simd             | teams           |                                    |
2073   // | simd             | cancellation    |                                    |
2074   // |                  | point           |                                    |
2075   // | simd             | cancel          |                                    |
2076   // | simd             | taskloop        |                                    |
2077   // | simd             | taskloop simd   |                                    |
2078   // | simd             | distribute      |                                    |
2079   // | simd             | distribute      |                                    |
2080   // |                  | parallel for    |                                    |
2081   // | simd             | distribute      |                                    |
2082   // |                  |parallel for simd|                                    |
2083   // | simd             | distribute simd |                                    |
2084   // | simd             | target parallel |                                    |
2085   // |                  | for simd        |                                    |
2086   // +------------------+-----------------+------------------------------------+
2087   // | for simd         | parallel        |                                    |
2088   // | for simd         | for             |                                    |
2089   // | for simd         | for simd        |                                    |
2090   // | for simd         | master          |                                    |
2091   // | for simd         | critical        |                                    |
2092   // | for simd         | simd            | *                                  |
2093   // | for simd         | sections        |                                    |
2094   // | for simd         | section         |                                    |
2095   // | for simd         | single          |                                    |
2096   // | for simd         | parallel for    |                                    |
2097   // | for simd         |parallel for simd|                                    |
2098   // | for simd         |parallel sections|                                    |
2099   // | for simd         | task            |                                    |
2100   // | for simd         | taskyield       |                                    |
2101   // | for simd         | barrier         |                                    |
2102   // | for simd         | taskwait        |                                    |
2103   // | for simd         | taskgroup       |                                    |
2104   // | for simd         | flush           |                                    |
2105   // | for simd         | ordered         | + (with simd clause)               |
2106   // | for simd         | atomic          |                                    |
2107   // | for simd         | target          |                                    |
2108   // | for simd         | target parallel |                                    |
2109   // | for simd         | target parallel |                                    |
2110   // |                  | for             |                                    |
2111   // | for simd         | target enter    |                                    |
2112   // |                  | data            |                                    |
2113   // | for simd         | target exit     |                                    |
2114   // |                  | data            |                                    |
2115   // | for simd         | teams           |                                    |
2116   // | for simd         | cancellation    |                                    |
2117   // |                  | point           |                                    |
2118   // | for simd         | cancel          |                                    |
2119   // | for simd         | taskloop        |                                    |
2120   // | for simd         | taskloop simd   |                                    |
2121   // | for simd         | distribute      |                                    |
2122   // | for simd         | distribute      |                                    |
2123   // |                  | parallel for    |                                    |
2124   // | for simd         | distribute      |                                    |
2125   // |                  |parallel for simd|                                    |
2126   // | for simd         | distribute simd |                                    |
2127   // | for simd         | target parallel |                                    |
2128   // |                  | for simd        |                                    |
2129   // +------------------+-----------------+------------------------------------+
2130   // | parallel for simd| parallel        |                                    |
2131   // | parallel for simd| for             |                                    |
2132   // | parallel for simd| for simd        |                                    |
2133   // | parallel for simd| master          |                                    |
2134   // | parallel for simd| critical        |                                    |
2135   // | parallel for simd| simd            | *                                  |
2136   // | parallel for simd| sections        |                                    |
2137   // | parallel for simd| section         |                                    |
2138   // | parallel for simd| single          |                                    |
2139   // | parallel for simd| parallel for    |                                    |
2140   // | parallel for simd|parallel for simd|                                    |
2141   // | parallel for simd|parallel sections|                                    |
2142   // | parallel for simd| task            |                                    |
2143   // | parallel for simd| taskyield       |                                    |
2144   // | parallel for simd| barrier         |                                    |
2145   // | parallel for simd| taskwait        |                                    |
2146   // | parallel for simd| taskgroup       |                                    |
2147   // | parallel for simd| flush           |                                    |
2148   // | parallel for simd| ordered         | + (with simd clause)               |
2149   // | parallel for simd| atomic          |                                    |
2150   // | parallel for simd| target          |                                    |
2151   // | parallel for simd| target parallel |                                    |
2152   // | parallel for simd| target parallel |                                    |
2153   // |                  | for             |                                    |
2154   // | parallel for simd| target enter    |                                    |
2155   // |                  | data            |                                    |
2156   // | parallel for simd| target exit     |                                    |
2157   // |                  | data            |                                    |
2158   // | parallel for simd| teams           |                                    |
2159   // | parallel for simd| cancellation    |                                    |
2160   // |                  | point           |                                    |
2161   // | parallel for simd| cancel          |                                    |
2162   // | parallel for simd| taskloop        |                                    |
2163   // | parallel for simd| taskloop simd   |                                    |
2164   // | parallel for simd| distribute      |                                    |
2165   // | parallel for simd| distribute      |                                    |
2166   // |                  | parallel for    |                                    |
2167   // | parallel for simd| distribute      |                                    |
2168   // |                  |parallel for simd|                                    |
2169   // | parallel for simd| distribute simd |                                    |
2170   // |                  | for simd        |                                    |
2171   // +------------------+-----------------+------------------------------------+
2172   // | sections         | parallel        | *                                  |
2173   // | sections         | for             | +                                  |
2174   // | sections         | for simd        | +                                  |
2175   // | sections         | master          | +                                  |
2176   // | sections         | critical        | *                                  |
2177   // | sections         | simd            | *                                  |
2178   // | sections         | sections        | +                                  |
2179   // | sections         | section         | *                                  |
2180   // | sections         | single          | +                                  |
2181   // | sections         | parallel for    | *                                  |
2182   // | sections         |parallel for simd| *                                  |
2183   // | sections         |parallel sections| *                                  |
2184   // | sections         | task            | *                                  |
2185   // | sections         | taskyield       | *                                  |
2186   // | sections         | barrier         | +                                  |
2187   // | sections         | taskwait        | *                                  |
2188   // | sections         | taskgroup       | *                                  |
2189   // | sections         | flush           | *                                  |
2190   // | sections         | ordered         | +                                  |
2191   // | sections         | atomic          | *                                  |
2192   // | sections         | target          | *                                  |
2193   // | sections         | target parallel | *                                  |
2194   // | sections         | target parallel | *                                  |
2195   // |                  | for             |                                    |
2196   // | sections         | target enter    | *                                  |
2197   // |                  | data            |                                    |
2198   // | sections         | target exit     | *                                  |
2199   // |                  | data            |                                    |
2200   // | sections         | teams           | +                                  |
2201   // | sections         | cancellation    |                                    |
2202   // |                  | point           | !                                  |
2203   // | sections         | cancel          | !                                  |
2204   // | sections         | taskloop        | *                                  |
2205   // | sections         | taskloop simd   | *                                  |
2206   // | sections         | distribute      | +                                  |
2207   // | sections         | distribute      | +                                  |
2208   // |                  | parallel for    |                                    |
2209   // | sections         | distribute      | +                                  |
2210   // |                  |parallel for simd|                                    |
2211   // | sections         | distribute simd | +                                  |
2212   // | sections         | target parallel | +                                  |
2213   // |                  | for simd        |                                    |
2214   // +------------------+-----------------+------------------------------------+
2215   // | section          | parallel        | *                                  |
2216   // | section          | for             | +                                  |
2217   // | section          | for simd        | +                                  |
2218   // | section          | master          | +                                  |
2219   // | section          | critical        | *                                  |
2220   // | section          | simd            | *                                  |
2221   // | section          | sections        | +                                  |
2222   // | section          | section         | +                                  |
2223   // | section          | single          | +                                  |
2224   // | section          | parallel for    | *                                  |
2225   // | section          |parallel for simd| *                                  |
2226   // | section          |parallel sections| *                                  |
2227   // | section          | task            | *                                  |
2228   // | section          | taskyield       | *                                  |
2229   // | section          | barrier         | +                                  |
2230   // | section          | taskwait        | *                                  |
2231   // | section          | taskgroup       | *                                  |
2232   // | section          | flush           | *                                  |
2233   // | section          | ordered         | +                                  |
2234   // | section          | atomic          | *                                  |
2235   // | section          | target          | *                                  |
2236   // | section          | target parallel | *                                  |
2237   // | section          | target parallel | *                                  |
2238   // |                  | for             |                                    |
2239   // | section          | target enter    | *                                  |
2240   // |                  | data            |                                    |
2241   // | section          | target exit     | *                                  |
2242   // |                  | data            |                                    |
2243   // | section          | teams           | +                                  |
2244   // | section          | cancellation    |                                    |
2245   // |                  | point           | !                                  |
2246   // | section          | cancel          | !                                  |
2247   // | section          | taskloop        | *                                  |
2248   // | section          | taskloop simd   | *                                  |
2249   // | section          | distribute      | +                                  |
2250   // | section          | distribute      | +                                  |
2251   // |                  | parallel for    |                                    |
2252   // | section          | distribute      | +                                  |
2253   // |                  |parallel for simd|                                    |
2254   // | section          | distribute simd | +                                  |
2255   // | section          | target parallel | +                                  |
2256   // |                  | for simd        |                                    |
2257   // +------------------+-----------------+------------------------------------+
2258   // | single           | parallel        | *                                  |
2259   // | single           | for             | +                                  |
2260   // | single           | for simd        | +                                  |
2261   // | single           | master          | +                                  |
2262   // | single           | critical        | *                                  |
2263   // | single           | simd            | *                                  |
2264   // | single           | sections        | +                                  |
2265   // | single           | section         | +                                  |
2266   // | single           | single          | +                                  |
2267   // | single           | parallel for    | *                                  |
2268   // | single           |parallel for simd| *                                  |
2269   // | single           |parallel sections| *                                  |
2270   // | single           | task            | *                                  |
2271   // | single           | taskyield       | *                                  |
2272   // | single           | barrier         | +                                  |
2273   // | single           | taskwait        | *                                  |
2274   // | single           | taskgroup       | *                                  |
2275   // | single           | flush           | *                                  |
2276   // | single           | ordered         | +                                  |
2277   // | single           | atomic          | *                                  |
2278   // | single           | target          | *                                  |
2279   // | single           | target parallel | *                                  |
2280   // | single           | target parallel | *                                  |
2281   // |                  | for             |                                    |
2282   // | single           | target enter    | *                                  |
2283   // |                  | data            |                                    |
2284   // | single           | target exit     | *                                  |
2285   // |                  | data            |                                    |
2286   // | single           | teams           | +                                  |
2287   // | single           | cancellation    |                                    |
2288   // |                  | point           |                                    |
2289   // | single           | cancel          |                                    |
2290   // | single           | taskloop        | *                                  |
2291   // | single           | taskloop simd   | *                                  |
2292   // | single           | distribute      | +                                  |
2293   // | single           | distribute      | +                                  |
2294   // |                  | parallel for    |                                    |
2295   // | single           | distribute      | +                                  |
2296   // |                  |parallel for simd|                                    |
2297   // | single           | distribute simd | +                                  |
2298   // | single           | target parallel | +                                  |
2299   // |                  | for simd        |                                    |
2300   // +------------------+-----------------+------------------------------------+
2301   // | parallel for     | parallel        | *                                  |
2302   // | parallel for     | for             | +                                  |
2303   // | parallel for     | for simd        | +                                  |
2304   // | parallel for     | master          | +                                  |
2305   // | parallel for     | critical        | *                                  |
2306   // | parallel for     | simd            | *                                  |
2307   // | parallel for     | sections        | +                                  |
2308   // | parallel for     | section         | +                                  |
2309   // | parallel for     | single          | +                                  |
2310   // | parallel for     | parallel for    | *                                  |
2311   // | parallel for     |parallel for simd| *                                  |
2312   // | parallel for     |parallel sections| *                                  |
2313   // | parallel for     | task            | *                                  |
2314   // | parallel for     | taskyield       | *                                  |
2315   // | parallel for     | barrier         | +                                  |
2316   // | parallel for     | taskwait        | *                                  |
2317   // | parallel for     | taskgroup       | *                                  |
2318   // | parallel for     | flush           | *                                  |
2319   // | parallel for     | ordered         | * (if construct is ordered)        |
2320   // | parallel for     | atomic          | *                                  |
2321   // | parallel for     | target          | *                                  |
2322   // | parallel for     | target parallel | *                                  |
2323   // | parallel for     | target parallel | *                                  |
2324   // |                  | for             |                                    |
2325   // | parallel for     | target enter    | *                                  |
2326   // |                  | data            |                                    |
2327   // | parallel for     | target exit     | *                                  |
2328   // |                  | data            |                                    |
2329   // | parallel for     | teams           | +                                  |
2330   // | parallel for     | cancellation    |                                    |
2331   // |                  | point           | !                                  |
2332   // | parallel for     | cancel          | !                                  |
2333   // | parallel for     | taskloop        | *                                  |
2334   // | parallel for     | taskloop simd   | *                                  |
2335   // | parallel for     | distribute      | +                                  |
2336   // | parallel for     | distribute      | +                                  |
2337   // |                  | parallel for    |                                    |
2338   // | parallel for     | distribute      | +                                  |
2339   // |                  |parallel for simd|                                    |
2340   // | parallel for     | distribute simd | +                                  |
2341   // | parallel for     | target parallel | +                                  |
2342   // |                  | for simd        |                                    |
2343   // +------------------+-----------------+------------------------------------+
2344   // | parallel sections| parallel        | *                                  |
2345   // | parallel sections| for             | +                                  |
2346   // | parallel sections| for simd        | +                                  |
2347   // | parallel sections| master          | +                                  |
2348   // | parallel sections| critical        | +                                  |
2349   // | parallel sections| simd            | *                                  |
2350   // | parallel sections| sections        | +                                  |
2351   // | parallel sections| section         | *                                  |
2352   // | parallel sections| single          | +                                  |
2353   // | parallel sections| parallel for    | *                                  |
2354   // | parallel sections|parallel for simd| *                                  |
2355   // | parallel sections|parallel sections| *                                  |
2356   // | parallel sections| task            | *                                  |
2357   // | parallel sections| taskyield       | *                                  |
2358   // | parallel sections| barrier         | +                                  |
2359   // | parallel sections| taskwait        | *                                  |
2360   // | parallel sections| taskgroup       | *                                  |
2361   // | parallel sections| flush           | *                                  |
2362   // | parallel sections| ordered         | +                                  |
2363   // | parallel sections| atomic          | *                                  |
2364   // | parallel sections| target          | *                                  |
2365   // | parallel sections| target parallel | *                                  |
2366   // | parallel sections| target parallel | *                                  |
2367   // |                  | for             |                                    |
2368   // | parallel sections| target enter    | *                                  |
2369   // |                  | data            |                                    |
2370   // | parallel sections| target exit     | *                                  |
2371   // |                  | data            |                                    |
2372   // | parallel sections| teams           | +                                  |
2373   // | parallel sections| cancellation    |                                    |
2374   // |                  | point           | !                                  |
2375   // | parallel sections| cancel          | !                                  |
2376   // | parallel sections| taskloop        | *                                  |
2377   // | parallel sections| taskloop simd   | *                                  |
2378   // | parallel sections| distribute      | +                                  |
2379   // | parallel sections| distribute      | +                                  |
2380   // |                  | parallel for    |                                    |
2381   // | parallel sections| distribute      | +                                  |
2382   // |                  |parallel for simd|                                    |
2383   // | parallel sections| distribute simd | +                                  |
2384   // | parallel sections| target parallel | +                                  |
2385   // |                  | for simd        |                                    |
2386   // +------------------+-----------------+------------------------------------+
2387   // | task             | parallel        | *                                  |
2388   // | task             | for             | +                                  |
2389   // | task             | for simd        | +                                  |
2390   // | task             | master          | +                                  |
2391   // | task             | critical        | *                                  |
2392   // | task             | simd            | *                                  |
2393   // | task             | sections        | +                                  |
2394   // | task             | section         | +                                  |
2395   // | task             | single          | +                                  |
2396   // | task             | parallel for    | *                                  |
2397   // | task             |parallel for simd| *                                  |
2398   // | task             |parallel sections| *                                  |
2399   // | task             | task            | *                                  |
2400   // | task             | taskyield       | *                                  |
2401   // | task             | barrier         | +                                  |
2402   // | task             | taskwait        | *                                  |
2403   // | task             | taskgroup       | *                                  |
2404   // | task             | flush           | *                                  |
2405   // | task             | ordered         | +                                  |
2406   // | task             | atomic          | *                                  |
2407   // | task             | target          | *                                  |
2408   // | task             | target parallel | *                                  |
2409   // | task             | target parallel | *                                  |
2410   // |                  | for             |                                    |
2411   // | task             | target enter    | *                                  |
2412   // |                  | data            |                                    |
2413   // | task             | target exit     | *                                  |
2414   // |                  | data            |                                    |
2415   // | task             | teams           | +                                  |
2416   // | task             | cancellation    |                                    |
2417   // |                  | point           | !                                  |
2418   // | task             | cancel          | !                                  |
2419   // | task             | taskloop        | *                                  |
2420   // | task             | taskloop simd   | *                                  |
2421   // | task             | distribute      | +                                  |
2422   // | task             | distribute      | +                                  |
2423   // |                  | parallel for    |                                    |
2424   // | task             | distribute      | +                                  |
2425   // |                  |parallel for simd|                                    |
2426   // | task             | distribute simd | +                                  |
2427   // | task             | target parallel | +                                  |
2428   // |                  | for simd        |                                    |
2429   // +------------------+-----------------+------------------------------------+
2430   // | ordered          | parallel        | *                                  |
2431   // | ordered          | for             | +                                  |
2432   // | ordered          | for simd        | +                                  |
2433   // | ordered          | master          | *                                  |
2434   // | ordered          | critical        | *                                  |
2435   // | ordered          | simd            | *                                  |
2436   // | ordered          | sections        | +                                  |
2437   // | ordered          | section         | +                                  |
2438   // | ordered          | single          | +                                  |
2439   // | ordered          | parallel for    | *                                  |
2440   // | ordered          |parallel for simd| *                                  |
2441   // | ordered          |parallel sections| *                                  |
2442   // | ordered          | task            | *                                  |
2443   // | ordered          | taskyield       | *                                  |
2444   // | ordered          | barrier         | +                                  |
2445   // | ordered          | taskwait        | *                                  |
2446   // | ordered          | taskgroup       | *                                  |
2447   // | ordered          | flush           | *                                  |
2448   // | ordered          | ordered         | +                                  |
2449   // | ordered          | atomic          | *                                  |
2450   // | ordered          | target          | *                                  |
2451   // | ordered          | target parallel | *                                  |
2452   // | ordered          | target parallel | *                                  |
2453   // |                  | for             |                                    |
2454   // | ordered          | target enter    | *                                  |
2455   // |                  | data            |                                    |
2456   // | ordered          | target exit     | *                                  |
2457   // |                  | data            |                                    |
2458   // | ordered          | teams           | +                                  |
2459   // | ordered          | cancellation    |                                    |
2460   // |                  | point           |                                    |
2461   // | ordered          | cancel          |                                    |
2462   // | ordered          | taskloop        | *                                  |
2463   // | ordered          | taskloop simd   | *                                  |
2464   // | ordered          | distribute      | +                                  |
2465   // | ordered          | distribute      | +                                  |
2466   // |                  | parallel for    |                                    |
2467   // | ordered          | distribute      | +                                  |
2468   // |                  |parallel for simd|                                    |
2469   // | ordered          | distribute simd | +                                  |
2470   // | ordered          | target parallel | +                                  |
2471   // |                  | for simd        |                                    |
2472   // +------------------+-----------------+------------------------------------+
2473   // | atomic           | parallel        |                                    |
2474   // | atomic           | for             |                                    |
2475   // | atomic           | for simd        |                                    |
2476   // | atomic           | master          |                                    |
2477   // | atomic           | critical        |                                    |
2478   // | atomic           | simd            |                                    |
2479   // | atomic           | sections        |                                    |
2480   // | atomic           | section         |                                    |
2481   // | atomic           | single          |                                    |
2482   // | atomic           | parallel for    |                                    |
2483   // | atomic           |parallel for simd|                                    |
2484   // | atomic           |parallel sections|                                    |
2485   // | atomic           | task            |                                    |
2486   // | atomic           | taskyield       |                                    |
2487   // | atomic           | barrier         |                                    |
2488   // | atomic           | taskwait        |                                    |
2489   // | atomic           | taskgroup       |                                    |
2490   // | atomic           | flush           |                                    |
2491   // | atomic           | ordered         |                                    |
2492   // | atomic           | atomic          |                                    |
2493   // | atomic           | target          |                                    |
2494   // | atomic           | target parallel |                                    |
2495   // | atomic           | target parallel |                                    |
2496   // |                  | for             |                                    |
2497   // | atomic           | target enter    |                                    |
2498   // |                  | data            |                                    |
2499   // | atomic           | target exit     |                                    |
2500   // |                  | data            |                                    |
2501   // | atomic           | teams           |                                    |
2502   // | atomic           | cancellation    |                                    |
2503   // |                  | point           |                                    |
2504   // | atomic           | cancel          |                                    |
2505   // | atomic           | taskloop        |                                    |
2506   // | atomic           | taskloop simd   |                                    |
2507   // | atomic           | distribute      |                                    |
2508   // | atomic           | distribute      |                                    |
2509   // |                  | parallel for    |                                    |
2510   // | atomic           | distribute      |                                    |
2511   // |                  |parallel for simd|                                    |
2512   // | atomic           | distribute simd |                                    |
2513   // | atomic           | target parallel |                                    |
2514   // |                  | for simd        |                                    |
2515   // +------------------+-----------------+------------------------------------+
2516   // | target           | parallel        | *                                  |
2517   // | target           | for             | *                                  |
2518   // | target           | for simd        | *                                  |
2519   // | target           | master          | *                                  |
2520   // | target           | critical        | *                                  |
2521   // | target           | simd            | *                                  |
2522   // | target           | sections        | *                                  |
2523   // | target           | section         | *                                  |
2524   // | target           | single          | *                                  |
2525   // | target           | parallel for    | *                                  |
2526   // | target           |parallel for simd| *                                  |
2527   // | target           |parallel sections| *                                  |
2528   // | target           | task            | *                                  |
2529   // | target           | taskyield       | *                                  |
2530   // | target           | barrier         | *                                  |
2531   // | target           | taskwait        | *                                  |
2532   // | target           | taskgroup       | *                                  |
2533   // | target           | flush           | *                                  |
2534   // | target           | ordered         | *                                  |
2535   // | target           | atomic          | *                                  |
2536   // | target           | target          |                                    |
2537   // | target           | target parallel |                                    |
2538   // | target           | target parallel |                                    |
2539   // |                  | for             |                                    |
2540   // | target           | target enter    |                                    |
2541   // |                  | data            |                                    |
2542   // | target           | target exit     |                                    |
2543   // |                  | data            |                                    |
2544   // | target           | teams           | *                                  |
2545   // | target           | cancellation    |                                    |
2546   // |                  | point           |                                    |
2547   // | target           | cancel          |                                    |
2548   // | target           | taskloop        | *                                  |
2549   // | target           | taskloop simd   | *                                  |
2550   // | target           | distribute      | +                                  |
2551   // | target           | distribute      | +                                  |
2552   // |                  | parallel for    |                                    |
2553   // | target           | distribute      | +                                  |
2554   // |                  |parallel for simd|                                    |
2555   // | target           | distribute simd | +                                  |
2556   // | target           | target parallel |                                    |
2557   // |                  | for simd        |                                    |
2558   // +------------------+-----------------+------------------------------------+
2559   // | target parallel  | parallel        | *                                  |
2560   // | target parallel  | for             | *                                  |
2561   // | target parallel  | for simd        | *                                  |
2562   // | target parallel  | master          | *                                  |
2563   // | target parallel  | critical        | *                                  |
2564   // | target parallel  | simd            | *                                  |
2565   // | target parallel  | sections        | *                                  |
2566   // | target parallel  | section         | *                                  |
2567   // | target parallel  | single          | *                                  |
2568   // | target parallel  | parallel for    | *                                  |
2569   // | target parallel  |parallel for simd| *                                  |
2570   // | target parallel  |parallel sections| *                                  |
2571   // | target parallel  | task            | *                                  |
2572   // | target parallel  | taskyield       | *                                  |
2573   // | target parallel  | barrier         | *                                  |
2574   // | target parallel  | taskwait        | *                                  |
2575   // | target parallel  | taskgroup       | *                                  |
2576   // | target parallel  | flush           | *                                  |
2577   // | target parallel  | ordered         | *                                  |
2578   // | target parallel  | atomic          | *                                  |
2579   // | target parallel  | target          |                                    |
2580   // | target parallel  | target parallel |                                    |
2581   // | target parallel  | target parallel |                                    |
2582   // |                  | for             |                                    |
2583   // | target parallel  | target enter    |                                    |
2584   // |                  | data            |                                    |
2585   // | target parallel  | target exit     |                                    |
2586   // |                  | data            |                                    |
2587   // | target parallel  | teams           |                                    |
2588   // | target parallel  | cancellation    |                                    |
2589   // |                  | point           | !                                  |
2590   // | target parallel  | cancel          | !                                  |
2591   // | target parallel  | taskloop        | *                                  |
2592   // | target parallel  | taskloop simd   | *                                  |
2593   // | target parallel  | distribute      |                                    |
2594   // | target parallel  | distribute      |                                    |
2595   // |                  | parallel for    |                                    |
2596   // | target parallel  | distribute      |                                    |
2597   // |                  |parallel for simd|                                    |
2598   // | target parallel  | distribute simd |                                    |
2599   // | target parallel  | target parallel |                                    |
2600   // |                  | for simd        |                                    |
2601   // +------------------+-----------------+------------------------------------+
2602   // | target parallel  | parallel        | *                                  |
2603   // | for              |                 |                                    |
2604   // | target parallel  | for             | *                                  |
2605   // | for              |                 |                                    |
2606   // | target parallel  | for simd        | *                                  |
2607   // | for              |                 |                                    |
2608   // | target parallel  | master          | *                                  |
2609   // | for              |                 |                                    |
2610   // | target parallel  | critical        | *                                  |
2611   // | for              |                 |                                    |
2612   // | target parallel  | simd            | *                                  |
2613   // | for              |                 |                                    |
2614   // | target parallel  | sections        | *                                  |
2615   // | for              |                 |                                    |
2616   // | target parallel  | section         | *                                  |
2617   // | for              |                 |                                    |
2618   // | target parallel  | single          | *                                  |
2619   // | for              |                 |                                    |
2620   // | target parallel  | parallel for    | *                                  |
2621   // | for              |                 |                                    |
2622   // | target parallel  |parallel for simd| *                                  |
2623   // | for              |                 |                                    |
2624   // | target parallel  |parallel sections| *                                  |
2625   // | for              |                 |                                    |
2626   // | target parallel  | task            | *                                  |
2627   // | for              |                 |                                    |
2628   // | target parallel  | taskyield       | *                                  |
2629   // | for              |                 |                                    |
2630   // | target parallel  | barrier         | *                                  |
2631   // | for              |                 |                                    |
2632   // | target parallel  | taskwait        | *                                  |
2633   // | for              |                 |                                    |
2634   // | target parallel  | taskgroup       | *                                  |
2635   // | for              |                 |                                    |
2636   // | target parallel  | flush           | *                                  |
2637   // | for              |                 |                                    |
2638   // | target parallel  | ordered         | *                                  |
2639   // | for              |                 |                                    |
2640   // | target parallel  | atomic          | *                                  |
2641   // | for              |                 |                                    |
2642   // | target parallel  | target          |                                    |
2643   // | for              |                 |                                    |
2644   // | target parallel  | target parallel |                                    |
2645   // | for              |                 |                                    |
2646   // | target parallel  | target parallel |                                    |
2647   // | for              | for             |                                    |
2648   // | target parallel  | target enter    |                                    |
2649   // | for              | data            |                                    |
2650   // | target parallel  | target exit     |                                    |
2651   // | for              | data            |                                    |
2652   // | target parallel  | teams           |                                    |
2653   // | for              |                 |                                    |
2654   // | target parallel  | cancellation    |                                    |
2655   // | for              | point           | !                                  |
2656   // | target parallel  | cancel          | !                                  |
2657   // | for              |                 |                                    |
2658   // | target parallel  | taskloop        | *                                  |
2659   // | for              |                 |                                    |
2660   // | target parallel  | taskloop simd   | *                                  |
2661   // | for              |                 |                                    |
2662   // | target parallel  | distribute      |                                    |
2663   // | for              |                 |                                    |
2664   // | target parallel  | distribute      |                                    |
2665   // | for              | parallel for    |                                    |
2666   // | target parallel  | distribute      |                                    |
2667   // | for              |parallel for simd|                                    |
2668   // | target parallel  | distribute simd |                                    |
2669   // | for              |                 |                                    |
2670   // | target parallel  | target parallel |                                    |
2671   // | for              | for simd        |                                    |
2672   // +------------------+-----------------+------------------------------------+
2673   // | teams            | parallel        | *                                  |
2674   // | teams            | for             | +                                  |
2675   // | teams            | for simd        | +                                  |
2676   // | teams            | master          | +                                  |
2677   // | teams            | critical        | +                                  |
2678   // | teams            | simd            | +                                  |
2679   // | teams            | sections        | +                                  |
2680   // | teams            | section         | +                                  |
2681   // | teams            | single          | +                                  |
2682   // | teams            | parallel for    | *                                  |
2683   // | teams            |parallel for simd| *                                  |
2684   // | teams            |parallel sections| *                                  |
2685   // | teams            | task            | +                                  |
2686   // | teams            | taskyield       | +                                  |
2687   // | teams            | barrier         | +                                  |
2688   // | teams            | taskwait        | +                                  |
2689   // | teams            | taskgroup       | +                                  |
2690   // | teams            | flush           | +                                  |
2691   // | teams            | ordered         | +                                  |
2692   // | teams            | atomic          | +                                  |
2693   // | teams            | target          | +                                  |
2694   // | teams            | target parallel | +                                  |
2695   // | teams            | target parallel | +                                  |
2696   // |                  | for             |                                    |
2697   // | teams            | target enter    | +                                  |
2698   // |                  | data            |                                    |
2699   // | teams            | target exit     | +                                  |
2700   // |                  | data            |                                    |
2701   // | teams            | teams           | +                                  |
2702   // | teams            | cancellation    |                                    |
2703   // |                  | point           |                                    |
2704   // | teams            | cancel          |                                    |
2705   // | teams            | taskloop        | +                                  |
2706   // | teams            | taskloop simd   | +                                  |
2707   // | teams            | distribute      | !                                  |
2708   // | teams            | distribute      | !                                  |
2709   // |                  | parallel for    |                                    |
2710   // | teams            | distribute      | !                                  |
2711   // |                  |parallel for simd|                                    |
2712   // | teams            | distribute simd | !                                  |
2713   // | teams            | target parallel | +                                  |
2714   // |                  | for simd        |                                    |
2715   // +------------------+-----------------+------------------------------------+
2716   // | taskloop         | parallel        | *                                  |
2717   // | taskloop         | for             | +                                  |
2718   // | taskloop         | for simd        | +                                  |
2719   // | taskloop         | master          | +                                  |
2720   // | taskloop         | critical        | *                                  |
2721   // | taskloop         | simd            | *                                  |
2722   // | taskloop         | sections        | +                                  |
2723   // | taskloop         | section         | +                                  |
2724   // | taskloop         | single          | +                                  |
2725   // | taskloop         | parallel for    | *                                  |
2726   // | taskloop         |parallel for simd| *                                  |
2727   // | taskloop         |parallel sections| *                                  |
2728   // | taskloop         | task            | *                                  |
2729   // | taskloop         | taskyield       | *                                  |
2730   // | taskloop         | barrier         | +                                  |
2731   // | taskloop         | taskwait        | *                                  |
2732   // | taskloop         | taskgroup       | *                                  |
2733   // | taskloop         | flush           | *                                  |
2734   // | taskloop         | ordered         | +                                  |
2735   // | taskloop         | atomic          | *                                  |
2736   // | taskloop         | target          | *                                  |
2737   // | taskloop         | target parallel | *                                  |
2738   // | taskloop         | target parallel | *                                  |
2739   // |                  | for             |                                    |
2740   // | taskloop         | target enter    | *                                  |
2741   // |                  | data            |                                    |
2742   // | taskloop         | target exit     | *                                  |
2743   // |                  | data            |                                    |
2744   // | taskloop         | teams           | +                                  |
2745   // | taskloop         | cancellation    |                                    |
2746   // |                  | point           |                                    |
2747   // | taskloop         | cancel          |                                    |
2748   // | taskloop         | taskloop        | *                                  |
2749   // | taskloop         | distribute      | +                                  |
2750   // | taskloop         | distribute      | +                                  |
2751   // |                  | parallel for    |                                    |
2752   // | taskloop         | distribute      | +                                  |
2753   // |                  |parallel for simd|                                    |
2754   // | taskloop         | distribute simd | +                                  |
2755   // | taskloop         | target parallel | *                                  |
2756   // |                  | for simd        |                                    |
2757   // +------------------+-----------------+------------------------------------+
2758   // | taskloop simd    | parallel        |                                    |
2759   // | taskloop simd    | for             |                                    |
2760   // | taskloop simd    | for simd        |                                    |
2761   // | taskloop simd    | master          |                                    |
2762   // | taskloop simd    | critical        |                                    |
2763   // | taskloop simd    | simd            | *                                  |
2764   // | taskloop simd    | sections        |                                    |
2765   // | taskloop simd    | section         |                                    |
2766   // | taskloop simd    | single          |                                    |
2767   // | taskloop simd    | parallel for    |                                    |
2768   // | taskloop simd    |parallel for simd|                                    |
2769   // | taskloop simd    |parallel sections|                                    |
2770   // | taskloop simd    | task            |                                    |
2771   // | taskloop simd    | taskyield       |                                    |
2772   // | taskloop simd    | barrier         |                                    |
2773   // | taskloop simd    | taskwait        |                                    |
2774   // | taskloop simd    | taskgroup       |                                    |
2775   // | taskloop simd    | flush           |                                    |
2776   // | taskloop simd    | ordered         | + (with simd clause)               |
2777   // | taskloop simd    | atomic          |                                    |
2778   // | taskloop simd    | target          |                                    |
2779   // | taskloop simd    | target parallel |                                    |
2780   // | taskloop simd    | target parallel |                                    |
2781   // |                  | for             |                                    |
2782   // | taskloop simd    | target enter    |                                    |
2783   // |                  | data            |                                    |
2784   // | taskloop simd    | target exit     |                                    |
2785   // |                  | data            |                                    |
2786   // | taskloop simd    | teams           |                                    |
2787   // | taskloop simd    | cancellation    |                                    |
2788   // |                  | point           |                                    |
2789   // | taskloop simd    | cancel          |                                    |
2790   // | taskloop simd    | taskloop        |                                    |
2791   // | taskloop simd    | taskloop simd   |                                    |
2792   // | taskloop simd    | distribute      |                                    |
2793   // | taskloop simd    | distribute      |                                    |
2794   // |                  | parallel for    |                                    |
2795   // | taskloop simd    | distribute      |                                    |
2796   // |                  |parallel for simd|                                    |
2797   // | taskloop simd    | distribute simd |                                    |
2798   // | taskloop simd    | target parallel |                                    |
2799   // |                  | for simd        |                                    |
2800   // +------------------+-----------------+------------------------------------+
2801   // | distribute       | parallel        | *                                  |
2802   // | distribute       | for             | *                                  |
2803   // | distribute       | for simd        | *                                  |
2804   // | distribute       | master          | *                                  |
2805   // | distribute       | critical        | *                                  |
2806   // | distribute       | simd            | *                                  |
2807   // | distribute       | sections        | *                                  |
2808   // | distribute       | section         | *                                  |
2809   // | distribute       | single          | *                                  |
2810   // | distribute       | parallel for    | *                                  |
2811   // | distribute       |parallel for simd| *                                  |
2812   // | distribute       |parallel sections| *                                  |
2813   // | distribute       | task            | *                                  |
2814   // | distribute       | taskyield       | *                                  |
2815   // | distribute       | barrier         | *                                  |
2816   // | distribute       | taskwait        | *                                  |
2817   // | distribute       | taskgroup       | *                                  |
2818   // | distribute       | flush           | *                                  |
2819   // | distribute       | ordered         | +                                  |
2820   // | distribute       | atomic          | *                                  |
2821   // | distribute       | target          |                                    |
2822   // | distribute       | target parallel |                                    |
2823   // | distribute       | target parallel |                                    |
2824   // |                  | for             |                                    |
2825   // | distribute       | target enter    |                                    |
2826   // |                  | data            |                                    |
2827   // | distribute       | target exit     |                                    |
2828   // |                  | data            |                                    |
2829   // | distribute       | teams           |                                    |
2830   // | distribute       | cancellation    | +                                  |
2831   // |                  | point           |                                    |
2832   // | distribute       | cancel          | +                                  |
2833   // | distribute       | taskloop        | *                                  |
2834   // | distribute       | taskloop simd   | *                                  |
2835   // | distribute       | distribute      |                                    |
2836   // | distribute       | distribute      |                                    |
2837   // |                  | parallel for    |                                    |
2838   // | distribute       | distribute      |                                    |
2839   // |                  |parallel for simd|                                    |
2840   // | distribute       | distribute simd |                                    |
2841   // | distribute       | target parallel |                                    |
2842   // |                  | for simd        |                                    |
2843   // +------------------+-----------------+------------------------------------+
2844   // | distribute       | parallel        | *                                  |
2845   // | parallel for     |                 |                                    |
2846   // | distribute       | for             | *                                  |
2847   // | parallel for     |                 |                                    |
2848   // | distribute       | for simd        | *                                  |
2849   // | parallel for     |                 |                                    |
2850   // | distribute       | master          | *                                  |
2851   // | parallel for     |                 |                                    |
2852   // | distribute       | critical        | *                                  |
2853   // | parallel for     |                 |                                    |
2854   // | distribute       | simd            | *                                  |
2855   // | parallel for     |                 |                                    |
2856   // | distribute       | sections        | *                                  |
2857   // | parallel for     |                 |                                    |
2858   // | distribute       | section         | *                                  |
2859   // | parallel for     |                 |                                    |
2860   // | distribute       | single          | *                                  |
2861   // | parallel for     |                 |                                    |
2862   // | distribute       | parallel for    | *                                  |
2863   // | parallel for     |                 |                                    |
2864   // | distribute       |parallel for simd| *                                  |
2865   // | parallel for     |                 |                                    |
2866   // | distribute       |parallel sections| *                                  |
2867   // | parallel for     |                 |                                    |
2868   // | distribute       | task            | *                                  |
2869   // | parallel for     |                 |                                    |
2870   // | parallel for     |                 |                                    |
2871   // | distribute       | taskyield       | *                                  |
2872   // | parallel for     |                 |                                    |
2873   // | distribute       | barrier         | *                                  |
2874   // | parallel for     |                 |                                    |
2875   // | distribute       | taskwait        | *                                  |
2876   // | parallel for     |                 |                                    |
2877   // | distribute       | taskgroup       | *                                  |
2878   // | parallel for     |                 |                                    |
2879   // | distribute       | flush           | *                                  |
2880   // | parallel for     |                 |                                    |
2881   // | distribute       | ordered         | +                                  |
2882   // | parallel for     |                 |                                    |
2883   // | distribute       | atomic          | *                                  |
2884   // | parallel for     |                 |                                    |
2885   // | distribute       | target          |                                    |
2886   // | parallel for     |                 |                                    |
2887   // | distribute       | target parallel |                                    |
2888   // | parallel for     |                 |                                    |
2889   // | distribute       | target parallel |                                    |
2890   // | parallel for     | for             |                                    |
2891   // | distribute       | target enter    |                                    |
2892   // | parallel for     | data            |                                    |
2893   // | distribute       | target exit     |                                    |
2894   // | parallel for     | data            |                                    |
2895   // | distribute       | teams           |                                    |
2896   // | parallel for     |                 |                                    |
2897   // | distribute       | cancellation    | +                                  |
2898   // | parallel for     | point           |                                    |
2899   // | distribute       | cancel          | +                                  |
2900   // | parallel for     |                 |                                    |
2901   // | distribute       | taskloop        | *                                  |
2902   // | parallel for     |                 |                                    |
2903   // | distribute       | taskloop simd   | *                                  |
2904   // | parallel for     |                 |                                    |
2905   // | distribute       | distribute      |                                    |
2906   // | parallel for     |                 |                                    |
2907   // | distribute       | distribute      |                                    |
2908   // | parallel for     | parallel for    |                                    |
2909   // | distribute       | distribute      |                                    |
2910   // | parallel for     |parallel for simd|                                    |
2911   // | distribute       | distribute simd |                                    |
2912   // | parallel for     |                 |                                    |
2913   // | distribute       | target parallel |                                    |
2914   // | parallel for     | for simd        |                                    |
2915   // +------------------+-----------------+------------------------------------+
2916   // | distribute       | parallel        | *                                  |
2917   // | parallel for simd|                 |                                    |
2918   // | distribute       | for             | *                                  |
2919   // | parallel for simd|                 |                                    |
2920   // | distribute       | for simd        | *                                  |
2921   // | parallel for simd|                 |                                    |
2922   // | distribute       | master          | *                                  |
2923   // | parallel for simd|                 |                                    |
2924   // | distribute       | critical        | *                                  |
2925   // | parallel for simd|                 |                                    |
2926   // | distribute       | simd            | *                                  |
2927   // | parallel for simd|                 |                                    |
2928   // | distribute       | sections        | *                                  |
2929   // | parallel for simd|                 |                                    |
2930   // | distribute       | section         | *                                  |
2931   // | parallel for simd|                 |                                    |
2932   // | distribute       | single          | *                                  |
2933   // | parallel for simd|                 |                                    |
2934   // | distribute       | parallel for    | *                                  |
2935   // | parallel for simd|                 |                                    |
2936   // | distribute       |parallel for simd| *                                  |
2937   // | parallel for simd|                 |                                    |
2938   // | distribute       |parallel sections| *                                  |
2939   // | parallel for simd|                 |                                    |
2940   // | distribute       | task            | *                                  |
2941   // | parallel for simd|                 |                                    |
2942   // | distribute       | taskyield       | *                                  |
2943   // | parallel for simd|                 |                                    |
2944   // | distribute       | barrier         | *                                  |
2945   // | parallel for simd|                 |                                    |
2946   // | distribute       | taskwait        | *                                  |
2947   // | parallel for simd|                 |                                    |
2948   // | distribute       | taskgroup       | *                                  |
2949   // | parallel for simd|                 |                                    |
2950   // | distribute       | flush           | *                                  |
2951   // | parallel for simd|                 |                                    |
2952   // | distribute       | ordered         | +                                  |
2953   // | parallel for simd|                 |                                    |
2954   // | distribute       | atomic          | *                                  |
2955   // | parallel for simd|                 |                                    |
2956   // | distribute       | target          |                                    |
2957   // | parallel for simd|                 |                                    |
2958   // | distribute       | target parallel |                                    |
2959   // | parallel for simd|                 |                                    |
2960   // | distribute       | target parallel |                                    |
2961   // | parallel for simd| for             |                                    |
2962   // | distribute       | target enter    |                                    |
2963   // | parallel for simd| data            |                                    |
2964   // | distribute       | target exit     |                                    |
2965   // | parallel for simd| data            |                                    |
2966   // | distribute       | teams           |                                    |
2967   // | parallel for simd|                 |                                    |
2968   // | distribute       | cancellation    | +                                  |
2969   // | parallel for simd| point           |                                    |
2970   // | distribute       | cancel          | +                                  |
2971   // | parallel for simd|                 |                                    |
2972   // | distribute       | taskloop        | *                                  |
2973   // | parallel for simd|                 |                                    |
2974   // | distribute       | taskloop simd   | *                                  |
2975   // | parallel for simd|                 |                                    |
2976   // | distribute       | distribute      |                                    |
2977   // | parallel for simd|                 |                                    |
2978   // | distribute       | distribute      | *                                  |
2979   // | parallel for simd| parallel for    |                                    |
2980   // | distribute       | distribute      | *                                  |
2981   // | parallel for simd|parallel for simd|                                    |
2982   // | distribute       | distribute simd | *                                  |
2983   // | parallel for simd|                 |                                    |
2984   // | distribute       | target parallel |                                    |
2985   // | parallel for simd| for simd        |                                    |
2986   // +------------------+-----------------+------------------------------------+
2987   // | distribute simd  | parallel        | *                                  |
2988   // | distribute simd  | for             | *                                  |
2989   // | distribute simd  | for simd        | *                                  |
2990   // | distribute simd  | master          | *                                  |
2991   // | distribute simd  | critical        | *                                  |
2992   // | distribute simd  | simd            | *                                  |
2993   // | distribute simd  | sections        | *                                  |
2994   // | distribute simd  | section         | *                                  |
2995   // | distribute simd  | single          | *                                  |
2996   // | distribute simd  | parallel for    | *                                  |
2997   // | distribute simd  |parallel for simd| *                                  |
2998   // | distribute simd  |parallel sections| *                                  |
2999   // | distribute simd  | task            | *                                  |
3000   // | distribute simd  | taskyield       | *                                  |
3001   // | distribute simd  | barrier         | *                                  |
3002   // | distribute simd  | taskwait        | *                                  |
3003   // | distribute simd  | taskgroup       | *                                  |
3004   // | distribute simd  | flush           | *                                  |
3005   // | distribute simd  | ordered         | +                                  |
3006   // | distribute simd  | atomic          | *                                  |
3007   // | distribute simd  | target          | *                                  |
3008   // | distribute simd  | target parallel | *                                  |
3009   // | distribute simd  | target parallel | *                                  |
3010   // |                  | for             |                                    |
3011   // | distribute simd  | target enter    | *                                  |
3012   // |                  | data            |                                    |
3013   // | distribute simd  | target exit     | *                                  |
3014   // |                  | data            |                                    |
3015   // | distribute simd  | teams           | *                                  |
3016   // | distribute simd  | cancellation    | +                                  |
3017   // |                  | point           |                                    |
3018   // | distribute simd  | cancel          | +                                  |
3019   // | distribute simd  | taskloop        | *                                  |
3020   // | distribute simd  | taskloop simd   | *                                  |
3021   // | distribute simd  | distribute      |                                    |
3022   // | distribute simd  | distribute      | *                                  |
3023   // |                  | parallel for    |                                    |
3024   // | distribute simd  | distribute      | *                                  |
3025   // |                  |parallel for simd|                                    |
3026   // | distribute simd  | distribute simd | *                                  |
3027   // | distribute simd  | target parallel | *                                  |
3028   // |                  | for simd        |                                    |
3029   // +------------------+-----------------+------------------------------------+
3030   // | target parallel  | parallel        | *                                  |
3031   // | for simd         |                 |                                    |
3032   // | target parallel  | for             | *                                  |
3033   // | for simd         |                 |                                    |
3034   // | target parallel  | for simd        | *                                  |
3035   // | for simd         |                 |                                    |
3036   // | target parallel  | master          | *                                  |
3037   // | for simd         |                 |                                    |
3038   // | target parallel  | critical        | *                                  |
3039   // | for simd         |                 |                                    |
3040   // | target parallel  | simd            | !                                  |
3041   // | for simd         |                 |                                    |
3042   // | target parallel  | sections        | *                                  |
3043   // | for simd         |                 |                                    |
3044   // | target parallel  | section         | *                                  |
3045   // | for simd         |                 |                                    |
3046   // | target parallel  | single          | *                                  |
3047   // | for simd         |                 |                                    |
3048   // | target parallel  | parallel for    | *                                  |
3049   // | for simd         |                 |                                    |
3050   // | target parallel  |parallel for simd| *                                  |
3051   // | for simd         |                 |                                    |
3052   // | target parallel  |parallel sections| *                                  |
3053   // | for simd         |                 |                                    |
3054   // | target parallel  | task            | *                                  |
3055   // | for simd         |                 |                                    |
3056   // | target parallel  | taskyield       | *                                  |
3057   // | for simd         |                 |                                    |
3058   // | target parallel  | barrier         | *                                  |
3059   // | for simd         |                 |                                    |
3060   // | target parallel  | taskwait        | *                                  |
3061   // | for simd         |                 |                                    |
3062   // | target parallel  | taskgroup       | *                                  |
3063   // | for simd         |                 |                                    |
3064   // | target parallel  | flush           | *                                  |
3065   // | for simd         |                 |                                    |
3066   // | target parallel  | ordered         | + (with simd clause)               |
3067   // | for simd         |                 |                                    |
3068   // | target parallel  | atomic          | *                                  |
3069   // | for simd         |                 |                                    |
3070   // | target parallel  | target          | *                                  |
3071   // | for simd         |                 |                                    |
3072   // | target parallel  | target parallel | *                                  |
3073   // | for simd         |                 |                                    |
3074   // | target parallel  | target parallel | *                                  |
3075   // | for simd         | for             |                                    |
3076   // | target parallel  | target enter    | *                                  |
3077   // | for simd         | data            |                                    |
3078   // | target parallel  | target exit     | *                                  |
3079   // | for simd         | data            |                                    |
3080   // | target parallel  | teams           | *                                  |
3081   // | for simd         |                 |                                    |
3082   // | target parallel  | cancellation    | *                                  |
3083   // | for simd         | point           |                                    |
3084   // | target parallel  | cancel          | *                                  |
3085   // | for simd         |                 |                                    |
3086   // | target parallel  | taskloop        | *                                  |
3087   // | for simd         |                 |                                    |
3088   // | target parallel  | taskloop simd   | *                                  |
3089   // | for simd         |                 |                                    |
3090   // | target parallel  | distribute      | *                                  |
3091   // | for simd         |                 |                                    |
3092   // | target parallel  | distribute      | *                                  |
3093   // | for simd         | parallel for    |                                    |
3094   // | target parallel  | distribute      | *                                  |
3095   // | for simd         |parallel for simd|                                    |
3096   // | target parallel  | distribute simd | *                                  |
3097   // | for simd         |                 |                                    |
3098   // | target parallel  | target parallel | *                                  |
3099   // | for simd         | for simd        |                                    |
3100   // +------------------+-----------------+------------------------------------+
3101   if (Stack->getCurScope()) {
3102     auto ParentRegion = Stack->getParentDirective();
3103     auto OffendingRegion = ParentRegion;
3104     bool NestingProhibited = false;
3105     bool CloseNesting = true;
3106     enum {
3107       NoRecommend,
3108       ShouldBeInParallelRegion,
3109       ShouldBeInOrderedRegion,
3110       ShouldBeInTargetRegion,
3111       ShouldBeInTeamsRegion
3112     } Recommend = NoRecommend;
3113     if (isOpenMPSimdDirective(ParentRegion) && CurrentRegion != OMPD_ordered) {
3114       // OpenMP [2.16, Nesting of Regions]
3115       // OpenMP constructs may not be nested inside a simd region.
3116       // OpenMP [2.8.1,simd Construct, Restrictions]
3117       // An ordered construct with the simd clause is the only OpenMP
3118       // construct that can appear in the simd region.
3119       // Allowing a SIMD consruct nested in another SIMD construct is an
3120       // extension. The OpenMP 4.5 spec does not allow it. Issue a warning
3121       // message.
3122       SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd)
3123                                  ? diag::err_omp_prohibited_region_simd
3124                                  : diag::warn_omp_nesting_simd);
3125       return CurrentRegion != OMPD_simd;
3126     }
3127     if (ParentRegion == OMPD_atomic) {
3128       // OpenMP [2.16, Nesting of Regions]
3129       // OpenMP constructs may not be nested inside an atomic region.
3130       SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic);
3131       return true;
3132     }
3133     if (CurrentRegion == OMPD_section) {
3134       // OpenMP [2.7.2, sections Construct, Restrictions]
3135       // Orphaned section directives are prohibited. That is, the section
3136       // directives must appear within the sections construct and must not be
3137       // encountered elsewhere in the sections region.
3138       if (ParentRegion != OMPD_sections &&
3139           ParentRegion != OMPD_parallel_sections) {
3140         SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
3141             << (ParentRegion != OMPD_unknown)
3142             << getOpenMPDirectiveName(ParentRegion);
3143         return true;
3144       }
3145       return false;
3146     }
3147     // Allow some constructs to be orphaned (they could be used in functions,
3148     // called from OpenMP regions with the required preconditions).
3149     if (ParentRegion == OMPD_unknown)
3150       return false;
3151     if (CurrentRegion == OMPD_cancellation_point ||
3152         CurrentRegion == OMPD_cancel) {
3153       // OpenMP [2.16, Nesting of Regions]
3154       // A cancellation point construct for which construct-type-clause is
3155       // taskgroup must be nested inside a task construct. A cancellation
3156       // point construct for which construct-type-clause is not taskgroup must
3157       // be closely nested inside an OpenMP construct that matches the type
3158       // specified in construct-type-clause.
3159       // A cancel construct for which construct-type-clause is taskgroup must be
3160       // nested inside a task construct. A cancel construct for which
3161       // construct-type-clause is not taskgroup must be closely nested inside an
3162       // OpenMP construct that matches the type specified in
3163       // construct-type-clause.
3164       NestingProhibited =
3165           !((CancelRegion == OMPD_parallel &&
3166              (ParentRegion == OMPD_parallel ||
3167               ParentRegion == OMPD_target_parallel)) ||
3168             (CancelRegion == OMPD_for &&
3169              (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for ||
3170               ParentRegion == OMPD_target_parallel_for)) ||
3171             (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) ||
3172             (CancelRegion == OMPD_sections &&
3173              (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
3174               ParentRegion == OMPD_parallel_sections)));
3175     } else if (CurrentRegion == OMPD_master) {
3176       // OpenMP [2.16, Nesting of Regions]
3177       // A master region may not be closely nested inside a worksharing,
3178       // atomic, or explicit task region.
3179       NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
3180                           isOpenMPTaskingDirective(ParentRegion);
3181     } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
3182       // OpenMP [2.16, Nesting of Regions]
3183       // A critical region may not be nested (closely or otherwise) inside a
3184       // critical region with the same name. Note that this restriction is not
3185       // sufficient to prevent deadlock.
3186       SourceLocation PreviousCriticalLoc;
3187       bool DeadLock =
3188           Stack->hasDirective([CurrentName, &PreviousCriticalLoc](
3189                                   OpenMPDirectiveKind K,
3190                                   const DeclarationNameInfo &DNI,
3191                                   SourceLocation Loc)
3192                                   ->bool {
3193                                 if (K == OMPD_critical &&
3194                                     DNI.getName() == CurrentName.getName()) {
3195                                   PreviousCriticalLoc = Loc;
3196                                   return true;
3197                                 } else
3198                                   return false;
3199                               },
3200                               false /* skip top directive */);
3201       if (DeadLock) {
3202         SemaRef.Diag(StartLoc,
3203                      diag::err_omp_prohibited_region_critical_same_name)
3204             << CurrentName.getName();
3205         if (PreviousCriticalLoc.isValid())
3206           SemaRef.Diag(PreviousCriticalLoc,
3207                        diag::note_omp_previous_critical_region);
3208         return true;
3209       }
3210     } else if (CurrentRegion == OMPD_barrier) {
3211       // OpenMP [2.16, Nesting of Regions]
3212       // A barrier region may not be closely nested inside a worksharing,
3213       // explicit task, critical, ordered, atomic, or master region.
3214       NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
3215                           isOpenMPTaskingDirective(ParentRegion) ||
3216                           ParentRegion == OMPD_master ||
3217                           ParentRegion == OMPD_critical ||
3218                           ParentRegion == OMPD_ordered;
3219     } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
3220                !isOpenMPParallelDirective(CurrentRegion)) {
3221       // OpenMP [2.16, Nesting of Regions]
3222       // A worksharing region may not be closely nested inside a worksharing,
3223       // explicit task, critical, ordered, atomic, or master region.
3224       NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
3225                           isOpenMPTaskingDirective(ParentRegion) ||
3226                           ParentRegion == OMPD_master ||
3227                           ParentRegion == OMPD_critical ||
3228                           ParentRegion == OMPD_ordered;
3229       Recommend = ShouldBeInParallelRegion;
3230     } else if (CurrentRegion == OMPD_ordered) {
3231       // OpenMP [2.16, Nesting of Regions]
3232       // An ordered region may not be closely nested inside a critical,
3233       // atomic, or explicit task region.
3234       // An ordered region must be closely nested inside a loop region (or
3235       // parallel loop region) with an ordered clause.
3236       // OpenMP [2.8.1,simd Construct, Restrictions]
3237       // An ordered construct with the simd clause is the only OpenMP construct
3238       // that can appear in the simd region.
3239       NestingProhibited = ParentRegion == OMPD_critical ||
3240                           isOpenMPTaskingDirective(ParentRegion) ||
3241                           !(isOpenMPSimdDirective(ParentRegion) ||
3242                             Stack->isParentOrderedRegion());
3243       Recommend = ShouldBeInOrderedRegion;
3244     } else if (isOpenMPTeamsDirective(CurrentRegion)) {
3245       // OpenMP [2.16, Nesting of Regions]
3246       // If specified, a teams construct must be contained within a target
3247       // construct.
3248       NestingProhibited = ParentRegion != OMPD_target;
3249       Recommend = ShouldBeInTargetRegion;
3250       Stack->setParentTeamsRegionLoc(Stack->getConstructLoc());
3251     }
3252     if (!NestingProhibited && isOpenMPTeamsDirective(ParentRegion)) {
3253       // OpenMP [2.16, Nesting of Regions]
3254       // distribute, parallel, parallel sections, parallel workshare, and the
3255       // parallel loop and parallel loop SIMD constructs are the only OpenMP
3256       // constructs that can be closely nested in the teams region.
3257       NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) &&
3258                           !isOpenMPDistributeDirective(CurrentRegion);
3259       Recommend = ShouldBeInParallelRegion;
3260     }
3261     if (!NestingProhibited && isOpenMPDistributeDirective(CurrentRegion)) {
3262       // OpenMP 4.5 [2.17 Nesting of Regions]
3263       // The region associated with the distribute construct must be strictly
3264       // nested inside a teams region
3265       NestingProhibited = !isOpenMPTeamsDirective(ParentRegion);
3266       Recommend = ShouldBeInTeamsRegion;
3267     }
3268     if (!NestingProhibited &&
3269         (isOpenMPTargetExecutionDirective(CurrentRegion) ||
3270          isOpenMPTargetDataManagementDirective(CurrentRegion))) {
3271       // OpenMP 4.5 [2.17 Nesting of Regions]
3272       // If a target, target update, target data, target enter data, or
3273       // target exit data construct is encountered during execution of a
3274       // target region, the behavior is unspecified.
3275       NestingProhibited = Stack->hasDirective(
3276           [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &,
3277                              SourceLocation) -> bool {
3278             if (isOpenMPTargetExecutionDirective(K)) {
3279               OffendingRegion = K;
3280               return true;
3281             } else
3282               return false;
3283           },
3284           false /* don't skip top directive */);
3285       CloseNesting = false;
3286     }
3287     if (NestingProhibited) {
3288       SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region)
3289           << CloseNesting << getOpenMPDirectiveName(OffendingRegion)
3290           << Recommend << getOpenMPDirectiveName(CurrentRegion);
3291       return true;
3292     }
3293   }
3294   return false;
3295 }
3296 
checkIfClauses(Sema & S,OpenMPDirectiveKind Kind,ArrayRef<OMPClause * > Clauses,ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers)3297 static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
3298                            ArrayRef<OMPClause *> Clauses,
3299                            ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
3300   bool ErrorFound = false;
3301   unsigned NamedModifiersNumber = 0;
3302   SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers(
3303       OMPD_unknown + 1);
3304   SmallVector<SourceLocation, 4> NameModifierLoc;
3305   for (const auto *C : Clauses) {
3306     if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {
3307       // At most one if clause without a directive-name-modifier can appear on
3308       // the directive.
3309       OpenMPDirectiveKind CurNM = IC->getNameModifier();
3310       if (FoundNameModifiers[CurNM]) {
3311         S.Diag(C->getLocStart(), diag::err_omp_more_one_clause)
3312             << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if)
3313             << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM);
3314         ErrorFound = true;
3315       } else if (CurNM != OMPD_unknown) {
3316         NameModifierLoc.push_back(IC->getNameModifierLoc());
3317         ++NamedModifiersNumber;
3318       }
3319       FoundNameModifiers[CurNM] = IC;
3320       if (CurNM == OMPD_unknown)
3321         continue;
3322       // Check if the specified name modifier is allowed for the current
3323       // directive.
3324       // At most one if clause with the particular directive-name-modifier can
3325       // appear on the directive.
3326       bool MatchFound = false;
3327       for (auto NM : AllowedNameModifiers) {
3328         if (CurNM == NM) {
3329           MatchFound = true;
3330           break;
3331         }
3332       }
3333       if (!MatchFound) {
3334         S.Diag(IC->getNameModifierLoc(),
3335                diag::err_omp_wrong_if_directive_name_modifier)
3336             << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind);
3337         ErrorFound = true;
3338       }
3339     }
3340   }
3341   // If any if clause on the directive includes a directive-name-modifier then
3342   // all if clauses on the directive must include a directive-name-modifier.
3343   if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {
3344     if (NamedModifiersNumber == AllowedNameModifiers.size()) {
3345       S.Diag(FoundNameModifiers[OMPD_unknown]->getLocStart(),
3346              diag::err_omp_no_more_if_clause);
3347     } else {
3348       std::string Values;
3349       std::string Sep(", ");
3350       unsigned AllowedCnt = 0;
3351       unsigned TotalAllowedNum =
3352           AllowedNameModifiers.size() - NamedModifiersNumber;
3353       for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End;
3354            ++Cnt) {
3355         OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt];
3356         if (!FoundNameModifiers[NM]) {
3357           Values += "'";
3358           Values += getOpenMPDirectiveName(NM);
3359           Values += "'";
3360           if (AllowedCnt + 2 == TotalAllowedNum)
3361             Values += " or ";
3362           else if (AllowedCnt + 1 != TotalAllowedNum)
3363             Values += Sep;
3364           ++AllowedCnt;
3365         }
3366       }
3367       S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getLocStart(),
3368              diag::err_omp_unnamed_if_clause)
3369           << (TotalAllowedNum > 1) << Values;
3370     }
3371     for (auto Loc : NameModifierLoc) {
3372       S.Diag(Loc, diag::note_omp_previous_named_if_clause);
3373     }
3374     ErrorFound = true;
3375   }
3376   return ErrorFound;
3377 }
3378 
ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind,const DeclarationNameInfo & DirName,OpenMPDirectiveKind CancelRegion,ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)3379 StmtResult Sema::ActOnOpenMPExecutableDirective(
3380     OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
3381     OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
3382     Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
3383   StmtResult Res = StmtError();
3384   if (CheckNestingOfRegions(*this, DSAStack, Kind, DirName, CancelRegion,
3385                             StartLoc))
3386     return StmtError();
3387 
3388   llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
3389   llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
3390   bool ErrorFound = false;
3391   ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
3392   if (AStmt) {
3393     assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
3394 
3395     // Check default data sharing attributes for referenced variables.
3396     DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt));
3397     DSAChecker.Visit(cast<CapturedStmt>(AStmt)->getCapturedStmt());
3398     if (DSAChecker.isErrorFound())
3399       return StmtError();
3400     // Generate list of implicitly defined firstprivate variables.
3401     VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA();
3402 
3403     if (!DSAChecker.getImplicitFirstprivate().empty()) {
3404       if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause(
3405               DSAChecker.getImplicitFirstprivate(), SourceLocation(),
3406               SourceLocation(), SourceLocation())) {
3407         ClausesWithImplicit.push_back(Implicit);
3408         ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() !=
3409                      DSAChecker.getImplicitFirstprivate().size();
3410       } else
3411         ErrorFound = true;
3412     }
3413   }
3414 
3415   llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
3416   switch (Kind) {
3417   case OMPD_parallel:
3418     Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
3419                                        EndLoc);
3420     AllowedNameModifiers.push_back(OMPD_parallel);
3421     break;
3422   case OMPD_simd:
3423     Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
3424                                    VarsWithInheritedDSA);
3425     break;
3426   case OMPD_for:
3427     Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
3428                                   VarsWithInheritedDSA);
3429     break;
3430   case OMPD_for_simd:
3431     Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
3432                                       EndLoc, VarsWithInheritedDSA);
3433     break;
3434   case OMPD_sections:
3435     Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
3436                                        EndLoc);
3437     break;
3438   case OMPD_section:
3439     assert(ClausesWithImplicit.empty() &&
3440            "No clauses are allowed for 'omp section' directive");
3441     Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
3442     break;
3443   case OMPD_single:
3444     Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
3445                                      EndLoc);
3446     break;
3447   case OMPD_master:
3448     assert(ClausesWithImplicit.empty() &&
3449            "No clauses are allowed for 'omp master' directive");
3450     Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
3451     break;
3452   case OMPD_critical:
3453     Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt,
3454                                        StartLoc, EndLoc);
3455     break;
3456   case OMPD_parallel_for:
3457     Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc,
3458                                           EndLoc, VarsWithInheritedDSA);
3459     AllowedNameModifiers.push_back(OMPD_parallel);
3460     break;
3461   case OMPD_parallel_for_simd:
3462     Res = ActOnOpenMPParallelForSimdDirective(
3463         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3464     AllowedNameModifiers.push_back(OMPD_parallel);
3465     break;
3466   case OMPD_parallel_sections:
3467     Res = ActOnOpenMPParallelSectionsDirective(ClausesWithImplicit, AStmt,
3468                                                StartLoc, EndLoc);
3469     AllowedNameModifiers.push_back(OMPD_parallel);
3470     break;
3471   case OMPD_task:
3472     Res =
3473         ActOnOpenMPTaskDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
3474     AllowedNameModifiers.push_back(OMPD_task);
3475     break;
3476   case OMPD_taskyield:
3477     assert(ClausesWithImplicit.empty() &&
3478            "No clauses are allowed for 'omp taskyield' directive");
3479     assert(AStmt == nullptr &&
3480            "No associated statement allowed for 'omp taskyield' directive");
3481     Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc);
3482     break;
3483   case OMPD_barrier:
3484     assert(ClausesWithImplicit.empty() &&
3485            "No clauses are allowed for 'omp barrier' directive");
3486     assert(AStmt == nullptr &&
3487            "No associated statement allowed for 'omp barrier' directive");
3488     Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
3489     break;
3490   case OMPD_taskwait:
3491     assert(ClausesWithImplicit.empty() &&
3492            "No clauses are allowed for 'omp taskwait' directive");
3493     assert(AStmt == nullptr &&
3494            "No associated statement allowed for 'omp taskwait' directive");
3495     Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc);
3496     break;
3497   case OMPD_taskgroup:
3498     assert(ClausesWithImplicit.empty() &&
3499            "No clauses are allowed for 'omp taskgroup' directive");
3500     Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc);
3501     break;
3502   case OMPD_flush:
3503     assert(AStmt == nullptr &&
3504            "No associated statement allowed for 'omp flush' directive");
3505     Res = ActOnOpenMPFlushDirective(ClausesWithImplicit, StartLoc, EndLoc);
3506     break;
3507   case OMPD_ordered:
3508     Res = ActOnOpenMPOrderedDirective(ClausesWithImplicit, AStmt, StartLoc,
3509                                       EndLoc);
3510     break;
3511   case OMPD_atomic:
3512     Res = ActOnOpenMPAtomicDirective(ClausesWithImplicit, AStmt, StartLoc,
3513                                      EndLoc);
3514     break;
3515   case OMPD_teams:
3516     Res =
3517         ActOnOpenMPTeamsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
3518     break;
3519   case OMPD_target:
3520     Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc,
3521                                      EndLoc);
3522     AllowedNameModifiers.push_back(OMPD_target);
3523     break;
3524   case OMPD_target_parallel:
3525     Res = ActOnOpenMPTargetParallelDirective(ClausesWithImplicit, AStmt,
3526                                              StartLoc, EndLoc);
3527     AllowedNameModifiers.push_back(OMPD_target);
3528     AllowedNameModifiers.push_back(OMPD_parallel);
3529     break;
3530   case OMPD_target_parallel_for:
3531     Res = ActOnOpenMPTargetParallelForDirective(
3532         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3533     AllowedNameModifiers.push_back(OMPD_target);
3534     AllowedNameModifiers.push_back(OMPD_parallel);
3535     break;
3536   case OMPD_cancellation_point:
3537     assert(ClausesWithImplicit.empty() &&
3538            "No clauses are allowed for 'omp cancellation point' directive");
3539     assert(AStmt == nullptr && "No associated statement allowed for 'omp "
3540                                "cancellation point' directive");
3541     Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion);
3542     break;
3543   case OMPD_cancel:
3544     assert(AStmt == nullptr &&
3545            "No associated statement allowed for 'omp cancel' directive");
3546     Res = ActOnOpenMPCancelDirective(ClausesWithImplicit, StartLoc, EndLoc,
3547                                      CancelRegion);
3548     AllowedNameModifiers.push_back(OMPD_cancel);
3549     break;
3550   case OMPD_target_data:
3551     Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc,
3552                                          EndLoc);
3553     AllowedNameModifiers.push_back(OMPD_target_data);
3554     break;
3555   case OMPD_target_enter_data:
3556     Res = ActOnOpenMPTargetEnterDataDirective(ClausesWithImplicit, StartLoc,
3557                                               EndLoc);
3558     AllowedNameModifiers.push_back(OMPD_target_enter_data);
3559     break;
3560   case OMPD_target_exit_data:
3561     Res = ActOnOpenMPTargetExitDataDirective(ClausesWithImplicit, StartLoc,
3562                                              EndLoc);
3563     AllowedNameModifiers.push_back(OMPD_target_exit_data);
3564     break;
3565   case OMPD_taskloop:
3566     Res = ActOnOpenMPTaskLoopDirective(ClausesWithImplicit, AStmt, StartLoc,
3567                                        EndLoc, VarsWithInheritedDSA);
3568     AllowedNameModifiers.push_back(OMPD_taskloop);
3569     break;
3570   case OMPD_taskloop_simd:
3571     Res = ActOnOpenMPTaskLoopSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
3572                                            EndLoc, VarsWithInheritedDSA);
3573     AllowedNameModifiers.push_back(OMPD_taskloop);
3574     break;
3575   case OMPD_distribute:
3576     Res = ActOnOpenMPDistributeDirective(ClausesWithImplicit, AStmt, StartLoc,
3577                                          EndLoc, VarsWithInheritedDSA);
3578     break;
3579   case OMPD_target_update:
3580     assert(!AStmt && "Statement is not allowed for target update");
3581     Res =
3582         ActOnOpenMPTargetUpdateDirective(ClausesWithImplicit, StartLoc, EndLoc);
3583     AllowedNameModifiers.push_back(OMPD_target_update);
3584     break;
3585   case OMPD_distribute_parallel_for:
3586     Res = ActOnOpenMPDistributeParallelForDirective(
3587         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3588     AllowedNameModifiers.push_back(OMPD_parallel);
3589     break;
3590   case OMPD_distribute_parallel_for_simd:
3591     Res = ActOnOpenMPDistributeParallelForSimdDirective(
3592         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3593     AllowedNameModifiers.push_back(OMPD_parallel);
3594     break;
3595   case OMPD_distribute_simd:
3596     Res = ActOnOpenMPDistributeSimdDirective(
3597         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3598     break;
3599   case OMPD_target_parallel_for_simd:
3600     Res = ActOnOpenMPTargetParallelForSimdDirective(
3601         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3602     AllowedNameModifiers.push_back(OMPD_target);
3603     AllowedNameModifiers.push_back(OMPD_parallel);
3604     break;
3605   case OMPD_declare_target:
3606   case OMPD_end_declare_target:
3607   case OMPD_threadprivate:
3608   case OMPD_declare_reduction:
3609   case OMPD_declare_simd:
3610     llvm_unreachable("OpenMP Directive is not allowed");
3611   case OMPD_unknown:
3612     llvm_unreachable("Unknown OpenMP directive");
3613   }
3614 
3615   for (auto P : VarsWithInheritedDSA) {
3616     Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
3617         << P.first << P.second->getSourceRange();
3618   }
3619   ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound;
3620 
3621   if (!AllowedNameModifiers.empty())
3622     ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) ||
3623                  ErrorFound;
3624 
3625   if (ErrorFound)
3626     return StmtError();
3627   return Res;
3628 }
3629 
ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG,OMPDeclareSimdDeclAttr::BranchStateTy BS,Expr * Simdlen,ArrayRef<Expr * > Uniforms,ArrayRef<Expr * > Aligneds,ArrayRef<Expr * > Alignments,ArrayRef<Expr * > Linears,ArrayRef<unsigned> LinModifiers,ArrayRef<Expr * > Steps,SourceRange SR)3630 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
3631     DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
3632     ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
3633     ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
3634     ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
3635   assert(Aligneds.size() == Alignments.size());
3636   assert(Linears.size() == LinModifiers.size());
3637   assert(Linears.size() == Steps.size());
3638   if (!DG || DG.get().isNull())
3639     return DeclGroupPtrTy();
3640 
3641   if (!DG.get().isSingleDecl()) {
3642     Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd);
3643     return DG;
3644   }
3645   auto *ADecl = DG.get().getSingleDecl();
3646   if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
3647     ADecl = FTD->getTemplatedDecl();
3648 
3649   auto *FD = dyn_cast<FunctionDecl>(ADecl);
3650   if (!FD) {
3651     Diag(ADecl->getLocation(), diag::err_omp_function_expected);
3652     return DeclGroupPtrTy();
3653   }
3654 
3655   // OpenMP [2.8.2, declare simd construct, Description]
3656   // The parameter of the simdlen clause must be a constant positive integer
3657   // expression.
3658   ExprResult SL;
3659   if (Simdlen)
3660     SL = VerifyPositiveIntegerConstantInClause(Simdlen, OMPC_simdlen);
3661   // OpenMP [2.8.2, declare simd construct, Description]
3662   // The special this pointer can be used as if was one of the arguments to the
3663   // function in any of the linear, aligned, or uniform clauses.
3664   // The uniform clause declares one or more arguments to have an invariant
3665   // value for all concurrent invocations of the function in the execution of a
3666   // single SIMD loop.
3667   llvm::DenseMap<Decl *, Expr *> UniformedArgs;
3668   Expr *UniformedLinearThis = nullptr;
3669   for (auto *E : Uniforms) {
3670     E = E->IgnoreParenImpCasts();
3671     if (auto *DRE = dyn_cast<DeclRefExpr>(E))
3672       if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
3673         if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
3674             FD->getParamDecl(PVD->getFunctionScopeIndex())
3675                     ->getCanonicalDecl() == PVD->getCanonicalDecl()) {
3676           UniformedArgs.insert(std::make_pair(PVD->getCanonicalDecl(), E));
3677           continue;
3678         }
3679     if (isa<CXXThisExpr>(E)) {
3680       UniformedLinearThis = E;
3681       continue;
3682     }
3683     Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
3684         << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
3685   }
3686   // OpenMP [2.8.2, declare simd construct, Description]
3687   // The aligned clause declares that the object to which each list item points
3688   // is aligned to the number of bytes expressed in the optional parameter of
3689   // the aligned clause.
3690   // The special this pointer can be used as if was one of the arguments to the
3691   // function in any of the linear, aligned, or uniform clauses.
3692   // The type of list items appearing in the aligned clause must be array,
3693   // pointer, reference to array, or reference to pointer.
3694   llvm::DenseMap<Decl *, Expr *> AlignedArgs;
3695   Expr *AlignedThis = nullptr;
3696   for (auto *E : Aligneds) {
3697     E = E->IgnoreParenImpCasts();
3698     if (auto *DRE = dyn_cast<DeclRefExpr>(E))
3699       if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
3700         auto *CanonPVD = PVD->getCanonicalDecl();
3701         if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
3702             FD->getParamDecl(PVD->getFunctionScopeIndex())
3703                     ->getCanonicalDecl() == CanonPVD) {
3704           // OpenMP  [2.8.1, simd construct, Restrictions]
3705           // A list-item cannot appear in more than one aligned clause.
3706           if (AlignedArgs.count(CanonPVD) > 0) {
3707             Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
3708                 << 1 << E->getSourceRange();
3709             Diag(AlignedArgs[CanonPVD]->getExprLoc(),
3710                  diag::note_omp_explicit_dsa)
3711                 << getOpenMPClauseName(OMPC_aligned);
3712             continue;
3713           }
3714           AlignedArgs[CanonPVD] = E;
3715           QualType QTy = PVD->getType()
3716                              .getNonReferenceType()
3717                              .getUnqualifiedType()
3718                              .getCanonicalType();
3719           const Type *Ty = QTy.getTypePtrOrNull();
3720           if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
3721             Diag(E->getExprLoc(), diag::err_omp_aligned_expected_array_or_ptr)
3722                 << QTy << getLangOpts().CPlusPlus << E->getSourceRange();
3723             Diag(PVD->getLocation(), diag::note_previous_decl) << PVD;
3724           }
3725           continue;
3726         }
3727       }
3728     if (isa<CXXThisExpr>(E)) {
3729       if (AlignedThis) {
3730         Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
3731             << 2 << E->getSourceRange();
3732         Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa)
3733             << getOpenMPClauseName(OMPC_aligned);
3734       }
3735       AlignedThis = E;
3736       continue;
3737     }
3738     Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
3739         << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
3740   }
3741   // The optional parameter of the aligned clause, alignment, must be a constant
3742   // positive integer expression. If no optional parameter is specified,
3743   // implementation-defined default alignments for SIMD instructions on the
3744   // target platforms are assumed.
3745   SmallVector<Expr *, 4> NewAligns;
3746   for (auto *E : Alignments) {
3747     ExprResult Align;
3748     if (E)
3749       Align = VerifyPositiveIntegerConstantInClause(E, OMPC_aligned);
3750     NewAligns.push_back(Align.get());
3751   }
3752   // OpenMP [2.8.2, declare simd construct, Description]
3753   // The linear clause declares one or more list items to be private to a SIMD
3754   // lane and to have a linear relationship with respect to the iteration space
3755   // of a loop.
3756   // The special this pointer can be used as if was one of the arguments to the
3757   // function in any of the linear, aligned, or uniform clauses.
3758   // When a linear-step expression is specified in a linear clause it must be
3759   // either a constant integer expression or an integer-typed parameter that is
3760   // specified in a uniform clause on the directive.
3761   llvm::DenseMap<Decl *, Expr *> LinearArgs;
3762   const bool IsUniformedThis = UniformedLinearThis != nullptr;
3763   auto MI = LinModifiers.begin();
3764   for (auto *E : Linears) {
3765     auto LinKind = static_cast<OpenMPLinearClauseKind>(*MI);
3766     ++MI;
3767     E = E->IgnoreParenImpCasts();
3768     if (auto *DRE = dyn_cast<DeclRefExpr>(E))
3769       if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
3770         auto *CanonPVD = PVD->getCanonicalDecl();
3771         if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
3772             FD->getParamDecl(PVD->getFunctionScopeIndex())
3773                     ->getCanonicalDecl() == CanonPVD) {
3774           // OpenMP  [2.15.3.7, linear Clause, Restrictions]
3775           // A list-item cannot appear in more than one linear clause.
3776           if (LinearArgs.count(CanonPVD) > 0) {
3777             Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
3778                 << getOpenMPClauseName(OMPC_linear)
3779                 << getOpenMPClauseName(OMPC_linear) << E->getSourceRange();
3780             Diag(LinearArgs[CanonPVD]->getExprLoc(),
3781                  diag::note_omp_explicit_dsa)
3782                 << getOpenMPClauseName(OMPC_linear);
3783             continue;
3784           }
3785           // Each argument can appear in at most one uniform or linear clause.
3786           if (UniformedArgs.count(CanonPVD) > 0) {
3787             Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
3788                 << getOpenMPClauseName(OMPC_linear)
3789                 << getOpenMPClauseName(OMPC_uniform) << E->getSourceRange();
3790             Diag(UniformedArgs[CanonPVD]->getExprLoc(),
3791                  diag::note_omp_explicit_dsa)
3792                 << getOpenMPClauseName(OMPC_uniform);
3793             continue;
3794           }
3795           LinearArgs[CanonPVD] = E;
3796           if (E->isValueDependent() || E->isTypeDependent() ||
3797               E->isInstantiationDependent() ||
3798               E->containsUnexpandedParameterPack())
3799             continue;
3800           (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind,
3801                                       PVD->getOriginalType());
3802           continue;
3803         }
3804       }
3805     if (isa<CXXThisExpr>(E)) {
3806       if (UniformedLinearThis) {
3807         Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
3808             << getOpenMPClauseName(OMPC_linear)
3809             << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear)
3810             << E->getSourceRange();
3811         Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa)
3812             << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform
3813                                                    : OMPC_linear);
3814         continue;
3815       }
3816       UniformedLinearThis = E;
3817       if (E->isValueDependent() || E->isTypeDependent() ||
3818           E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
3819         continue;
3820       (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind,
3821                                   E->getType());
3822       continue;
3823     }
3824     Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
3825         << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
3826   }
3827   Expr *Step = nullptr;
3828   Expr *NewStep = nullptr;
3829   SmallVector<Expr *, 4> NewSteps;
3830   for (auto *E : Steps) {
3831     // Skip the same step expression, it was checked already.
3832     if (Step == E || !E) {
3833       NewSteps.push_back(E ? NewStep : nullptr);
3834       continue;
3835     }
3836     Step = E;
3837     if (auto *DRE = dyn_cast<DeclRefExpr>(Step))
3838       if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
3839         auto *CanonPVD = PVD->getCanonicalDecl();
3840         if (UniformedArgs.count(CanonPVD) == 0) {
3841           Diag(Step->getExprLoc(), diag::err_omp_expected_uniform_param)
3842               << Step->getSourceRange();
3843         } else if (E->isValueDependent() || E->isTypeDependent() ||
3844                    E->isInstantiationDependent() ||
3845                    E->containsUnexpandedParameterPack() ||
3846                    CanonPVD->getType()->hasIntegerRepresentation())
3847           NewSteps.push_back(Step);
3848         else {
3849           Diag(Step->getExprLoc(), diag::err_omp_expected_int_param)
3850               << Step->getSourceRange();
3851         }
3852         continue;
3853       }
3854     NewStep = Step;
3855     if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
3856         !Step->isInstantiationDependent() &&
3857         !Step->containsUnexpandedParameterPack()) {
3858       NewStep = PerformOpenMPImplicitIntegerConversion(Step->getExprLoc(), Step)
3859                     .get();
3860       if (NewStep)
3861         NewStep = VerifyIntegerConstantExpression(NewStep).get();
3862     }
3863     NewSteps.push_back(NewStep);
3864   }
3865   auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
3866       Context, BS, SL.get(), const_cast<Expr **>(Uniforms.data()),
3867       Uniforms.size(), const_cast<Expr **>(Aligneds.data()), Aligneds.size(),
3868       const_cast<Expr **>(NewAligns.data()), NewAligns.size(),
3869       const_cast<Expr **>(Linears.data()), Linears.size(),
3870       const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(),
3871       NewSteps.data(), NewSteps.size(), SR);
3872   ADecl->addAttr(NewAttr);
3873   return ConvertDeclToDeclGroup(ADecl);
3874 }
3875 
ActOnOpenMPParallelDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)3876 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
3877                                               Stmt *AStmt,
3878                                               SourceLocation StartLoc,
3879                                               SourceLocation EndLoc) {
3880   if (!AStmt)
3881     return StmtError();
3882 
3883   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
3884   // 1.2.2 OpenMP Language Terminology
3885   // Structured block - An executable statement with a single entry at the
3886   // top and a single exit at the bottom.
3887   // The point of exit cannot be a branch out of the structured block.
3888   // longjmp() and throw() must not violate the entry/exit criteria.
3889   CS->getCapturedDecl()->setNothrow();
3890 
3891   getCurFunction()->setHasBranchProtectedScope();
3892 
3893   return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
3894                                       DSAStack->isCancelRegion());
3895 }
3896 
3897 namespace {
3898 /// \brief Helper class for checking canonical form of the OpenMP loops and
3899 /// extracting iteration space of each loop in the loop nest, that will be used
3900 /// for IR generation.
3901 class OpenMPIterationSpaceChecker {
3902   /// \brief Reference to Sema.
3903   Sema &SemaRef;
3904   /// \brief A location for diagnostics (when there is no some better location).
3905   SourceLocation DefaultLoc;
3906   /// \brief A location for diagnostics (when increment is not compatible).
3907   SourceLocation ConditionLoc;
3908   /// \brief A source location for referring to loop init later.
3909   SourceRange InitSrcRange;
3910   /// \brief A source location for referring to condition later.
3911   SourceRange ConditionSrcRange;
3912   /// \brief A source location for referring to increment later.
3913   SourceRange IncrementSrcRange;
3914   /// \brief Loop variable.
3915   ValueDecl *LCDecl = nullptr;
3916   /// \brief Reference to loop variable.
3917   Expr *LCRef = nullptr;
3918   /// \brief Lower bound (initializer for the var).
3919   Expr *LB = nullptr;
3920   /// \brief Upper bound.
3921   Expr *UB = nullptr;
3922   /// \brief Loop step (increment).
3923   Expr *Step = nullptr;
3924   /// \brief This flag is true when condition is one of:
3925   ///   Var <  UB
3926   ///   Var <= UB
3927   ///   UB  >  Var
3928   ///   UB  >= Var
3929   bool TestIsLessOp = false;
3930   /// \brief This flag is true when condition is strict ( < or > ).
3931   bool TestIsStrictOp = false;
3932   /// \brief This flag is true when step is subtracted on each iteration.
3933   bool SubtractStep = false;
3934 
3935 public:
OpenMPIterationSpaceChecker(Sema & SemaRef,SourceLocation DefaultLoc)3936   OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc)
3937       : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {}
3938   /// \brief Check init-expr for canonical loop form and save loop counter
3939   /// variable - #Var and its initialization value - #LB.
3940   bool CheckInit(Stmt *S, bool EmitDiags = true);
3941   /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags
3942   /// for less/greater and for strict/non-strict comparison.
3943   bool CheckCond(Expr *S);
3944   /// \brief Check incr-expr for canonical loop form and return true if it
3945   /// does not conform, otherwise save loop step (#Step).
3946   bool CheckInc(Expr *S);
3947   /// \brief Return the loop counter variable.
GetLoopDecl() const3948   ValueDecl *GetLoopDecl() const { return LCDecl; }
3949   /// \brief Return the reference expression to loop counter variable.
GetLoopDeclRefExpr() const3950   Expr *GetLoopDeclRefExpr() const { return LCRef; }
3951   /// \brief Source range of the loop init.
GetInitSrcRange() const3952   SourceRange GetInitSrcRange() const { return InitSrcRange; }
3953   /// \brief Source range of the loop condition.
GetConditionSrcRange() const3954   SourceRange GetConditionSrcRange() const { return ConditionSrcRange; }
3955   /// \brief Source range of the loop increment.
GetIncrementSrcRange() const3956   SourceRange GetIncrementSrcRange() const { return IncrementSrcRange; }
3957   /// \brief True if the step should be subtracted.
ShouldSubtractStep() const3958   bool ShouldSubtractStep() const { return SubtractStep; }
3959   /// \brief Build the expression to calculate the number of iterations.
3960   Expr *
3961   BuildNumIterations(Scope *S, const bool LimitedType,
3962                      llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
3963   /// \brief Build the precondition expression for the loops.
3964   Expr *BuildPreCond(Scope *S, Expr *Cond,
3965                      llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
3966   /// \brief Build reference expression to the counter be used for codegen.
3967   DeclRefExpr *BuildCounterVar(llvm::MapVector<Expr *, DeclRefExpr *> &Captures,
3968                                DSAStackTy &DSA) const;
3969   /// \brief Build reference expression to the private counter be used for
3970   /// codegen.
3971   Expr *BuildPrivateCounterVar() const;
3972   /// \brief Build initization of the counter be used for codegen.
3973   Expr *BuildCounterInit() const;
3974   /// \brief Build step of the counter be used for codegen.
3975   Expr *BuildCounterStep() const;
3976   /// \brief Return true if any expression is dependent.
3977   bool Dependent() const;
3978 
3979 private:
3980   /// \brief Check the right-hand side of an assignment in the increment
3981   /// expression.
3982   bool CheckIncRHS(Expr *RHS);
3983   /// \brief Helper to set loop counter variable and its initializer.
3984   bool SetLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB);
3985   /// \brief Helper to set upper bound.
3986   bool SetUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR,
3987              SourceLocation SL);
3988   /// \brief Helper to set loop increment.
3989   bool SetStep(Expr *NewStep, bool Subtract);
3990 };
3991 
Dependent() const3992 bool OpenMPIterationSpaceChecker::Dependent() const {
3993   if (!LCDecl) {
3994     assert(!LB && !UB && !Step);
3995     return false;
3996   }
3997   return LCDecl->getType()->isDependentType() ||
3998          (LB && LB->isValueDependent()) || (UB && UB->isValueDependent()) ||
3999          (Step && Step->isValueDependent());
4000 }
4001 
getExprAsWritten(Expr * E)4002 static Expr *getExprAsWritten(Expr *E) {
4003   if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(E))
4004     E = ExprTemp->getSubExpr();
4005 
4006   if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
4007     E = MTE->GetTemporaryExpr();
4008 
4009   while (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
4010     E = Binder->getSubExpr();
4011 
4012   if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
4013     E = ICE->getSubExprAsWritten();
4014   return E->IgnoreParens();
4015 }
4016 
SetLCDeclAndLB(ValueDecl * NewLCDecl,Expr * NewLCRefExpr,Expr * NewLB)4017 bool OpenMPIterationSpaceChecker::SetLCDeclAndLB(ValueDecl *NewLCDecl,
4018                                                  Expr *NewLCRefExpr,
4019                                                  Expr *NewLB) {
4020   // State consistency checking to ensure correct usage.
4021   assert(LCDecl == nullptr && LB == nullptr && LCRef == nullptr &&
4022          UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
4023   if (!NewLCDecl || !NewLB)
4024     return true;
4025   LCDecl = getCanonicalDecl(NewLCDecl);
4026   LCRef = NewLCRefExpr;
4027   if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(NewLB))
4028     if (const CXXConstructorDecl *Ctor = CE->getConstructor())
4029       if ((Ctor->isCopyOrMoveConstructor() ||
4030            Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
4031           CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
4032         NewLB = CE->getArg(0)->IgnoreParenImpCasts();
4033   LB = NewLB;
4034   return false;
4035 }
4036 
SetUB(Expr * NewUB,bool LessOp,bool StrictOp,SourceRange SR,SourceLocation SL)4037 bool OpenMPIterationSpaceChecker::SetUB(Expr *NewUB, bool LessOp, bool StrictOp,
4038                                         SourceRange SR, SourceLocation SL) {
4039   // State consistency checking to ensure correct usage.
4040   assert(LCDecl != nullptr && LB != nullptr && UB == nullptr &&
4041          Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
4042   if (!NewUB)
4043     return true;
4044   UB = NewUB;
4045   TestIsLessOp = LessOp;
4046   TestIsStrictOp = StrictOp;
4047   ConditionSrcRange = SR;
4048   ConditionLoc = SL;
4049   return false;
4050 }
4051 
SetStep(Expr * NewStep,bool Subtract)4052 bool OpenMPIterationSpaceChecker::SetStep(Expr *NewStep, bool Subtract) {
4053   // State consistency checking to ensure correct usage.
4054   assert(LCDecl != nullptr && LB != nullptr && Step == nullptr);
4055   if (!NewStep)
4056     return true;
4057   if (!NewStep->isValueDependent()) {
4058     // Check that the step is integer expression.
4059     SourceLocation StepLoc = NewStep->getLocStart();
4060     ExprResult Val =
4061         SemaRef.PerformOpenMPImplicitIntegerConversion(StepLoc, NewStep);
4062     if (Val.isInvalid())
4063       return true;
4064     NewStep = Val.get();
4065 
4066     // OpenMP [2.6, Canonical Loop Form, Restrictions]
4067     //  If test-expr is of form var relational-op b and relational-op is < or
4068     //  <= then incr-expr must cause var to increase on each iteration of the
4069     //  loop. If test-expr is of form var relational-op b and relational-op is
4070     //  > or >= then incr-expr must cause var to decrease on each iteration of
4071     //  the loop.
4072     //  If test-expr is of form b relational-op var and relational-op is < or
4073     //  <= then incr-expr must cause var to decrease on each iteration of the
4074     //  loop. If test-expr is of form b relational-op var and relational-op is
4075     //  > or >= then incr-expr must cause var to increase on each iteration of
4076     //  the loop.
4077     llvm::APSInt Result;
4078     bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context);
4079     bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation();
4080     bool IsConstNeg =
4081         IsConstant && Result.isSigned() && (Subtract != Result.isNegative());
4082     bool IsConstPos =
4083         IsConstant && Result.isSigned() && (Subtract == Result.isNegative());
4084     bool IsConstZero = IsConstant && !Result.getBoolValue();
4085     if (UB && (IsConstZero ||
4086                (TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract))
4087                              : (IsConstPos || (IsUnsigned && !Subtract))))) {
4088       SemaRef.Diag(NewStep->getExprLoc(),
4089                    diag::err_omp_loop_incr_not_compatible)
4090           << LCDecl << TestIsLessOp << NewStep->getSourceRange();
4091       SemaRef.Diag(ConditionLoc,
4092                    diag::note_omp_loop_cond_requres_compatible_incr)
4093           << TestIsLessOp << ConditionSrcRange;
4094       return true;
4095     }
4096     if (TestIsLessOp == Subtract) {
4097       NewStep = SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus,
4098                                              NewStep).get();
4099       Subtract = !Subtract;
4100     }
4101   }
4102 
4103   Step = NewStep;
4104   SubtractStep = Subtract;
4105   return false;
4106 }
4107 
CheckInit(Stmt * S,bool EmitDiags)4108 bool OpenMPIterationSpaceChecker::CheckInit(Stmt *S, bool EmitDiags) {
4109   // Check init-expr for canonical loop form and save loop counter
4110   // variable - #Var and its initialization value - #LB.
4111   // OpenMP [2.6] Canonical loop form. init-expr may be one of the following:
4112   //   var = lb
4113   //   integer-type var = lb
4114   //   random-access-iterator-type var = lb
4115   //   pointer-type var = lb
4116   //
4117   if (!S) {
4118     if (EmitDiags) {
4119       SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_init);
4120     }
4121     return true;
4122   }
4123   if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
4124     if (!ExprTemp->cleanupsHaveSideEffects())
4125       S = ExprTemp->getSubExpr();
4126 
4127   InitSrcRange = S->getSourceRange();
4128   if (Expr *E = dyn_cast<Expr>(S))
4129     S = E->IgnoreParens();
4130   if (auto BO = dyn_cast<BinaryOperator>(S)) {
4131     if (BO->getOpcode() == BO_Assign) {
4132       auto *LHS = BO->getLHS()->IgnoreParens();
4133       if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
4134         if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
4135           if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
4136             return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4137         return SetLCDeclAndLB(DRE->getDecl(), DRE, BO->getRHS());
4138       }
4139       if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
4140         if (ME->isArrow() &&
4141             isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
4142           return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4143       }
4144     }
4145   } else if (auto DS = dyn_cast<DeclStmt>(S)) {
4146     if (DS->isSingleDecl()) {
4147       if (auto Var = dyn_cast_or_null<VarDecl>(DS->getSingleDecl())) {
4148         if (Var->hasInit() && !Var->getType()->isReferenceType()) {
4149           // Accept non-canonical init form here but emit ext. warning.
4150           if (Var->getInitStyle() != VarDecl::CInit && EmitDiags)
4151             SemaRef.Diag(S->getLocStart(),
4152                          diag::ext_omp_loop_not_canonical_init)
4153                 << S->getSourceRange();
4154           return SetLCDeclAndLB(Var, nullptr, Var->getInit());
4155         }
4156       }
4157     }
4158   } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) {
4159     if (CE->getOperator() == OO_Equal) {
4160       auto *LHS = CE->getArg(0);
4161       if (auto DRE = dyn_cast<DeclRefExpr>(LHS)) {
4162         if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
4163           if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
4164             return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4165         return SetLCDeclAndLB(DRE->getDecl(), DRE, CE->getArg(1));
4166       }
4167       if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
4168         if (ME->isArrow() &&
4169             isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
4170           return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4171       }
4172     }
4173   }
4174 
4175   if (Dependent() || SemaRef.CurContext->isDependentContext())
4176     return false;
4177   if (EmitDiags) {
4178     SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_init)
4179         << S->getSourceRange();
4180   }
4181   return true;
4182 }
4183 
4184 /// \brief Ignore parenthesizes, implicit casts, copy constructor and return the
4185 /// variable (which may be the loop variable) if possible.
GetInitLCDecl(Expr * E)4186 static const ValueDecl *GetInitLCDecl(Expr *E) {
4187   if (!E)
4188     return nullptr;
4189   E = getExprAsWritten(E);
4190   if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(E))
4191     if (const CXXConstructorDecl *Ctor = CE->getConstructor())
4192       if ((Ctor->isCopyOrMoveConstructor() ||
4193            Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
4194           CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
4195         E = CE->getArg(0)->IgnoreParenImpCasts();
4196   if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
4197     if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
4198       if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
4199         if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
4200           return getCanonicalDecl(ME->getMemberDecl());
4201       return getCanonicalDecl(VD);
4202     }
4203   }
4204   if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
4205     if (ME->isArrow() && isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
4206       return getCanonicalDecl(ME->getMemberDecl());
4207   return nullptr;
4208 }
4209 
CheckCond(Expr * S)4210 bool OpenMPIterationSpaceChecker::CheckCond(Expr *S) {
4211   // Check test-expr for canonical form, save upper-bound UB, flags for
4212   // less/greater and for strict/non-strict comparison.
4213   // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
4214   //   var relational-op b
4215   //   b relational-op var
4216   //
4217   if (!S) {
4218     SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_cond) << LCDecl;
4219     return true;
4220   }
4221   S = getExprAsWritten(S);
4222   SourceLocation CondLoc = S->getLocStart();
4223   if (auto BO = dyn_cast<BinaryOperator>(S)) {
4224     if (BO->isRelationalOp()) {
4225       if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4226         return SetUB(BO->getRHS(),
4227                      (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_LE),
4228                      (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
4229                      BO->getSourceRange(), BO->getOperatorLoc());
4230       if (GetInitLCDecl(BO->getRHS()) == LCDecl)
4231         return SetUB(BO->getLHS(),
4232                      (BO->getOpcode() == BO_GT || BO->getOpcode() == BO_GE),
4233                      (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
4234                      BO->getSourceRange(), BO->getOperatorLoc());
4235     }
4236   } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) {
4237     if (CE->getNumArgs() == 2) {
4238       auto Op = CE->getOperator();
4239       switch (Op) {
4240       case OO_Greater:
4241       case OO_GreaterEqual:
4242       case OO_Less:
4243       case OO_LessEqual:
4244         if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4245           return SetUB(CE->getArg(1), Op == OO_Less || Op == OO_LessEqual,
4246                        Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
4247                        CE->getOperatorLoc());
4248         if (GetInitLCDecl(CE->getArg(1)) == LCDecl)
4249           return SetUB(CE->getArg(0), Op == OO_Greater || Op == OO_GreaterEqual,
4250                        Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
4251                        CE->getOperatorLoc());
4252         break;
4253       default:
4254         break;
4255       }
4256     }
4257   }
4258   if (Dependent() || SemaRef.CurContext->isDependentContext())
4259     return false;
4260   SemaRef.Diag(CondLoc, diag::err_omp_loop_not_canonical_cond)
4261       << S->getSourceRange() << LCDecl;
4262   return true;
4263 }
4264 
CheckIncRHS(Expr * RHS)4265 bool OpenMPIterationSpaceChecker::CheckIncRHS(Expr *RHS) {
4266   // RHS of canonical loop form increment can be:
4267   //   var + incr
4268   //   incr + var
4269   //   var - incr
4270   //
4271   RHS = RHS->IgnoreParenImpCasts();
4272   if (auto BO = dyn_cast<BinaryOperator>(RHS)) {
4273     if (BO->isAdditiveOp()) {
4274       bool IsAdd = BO->getOpcode() == BO_Add;
4275       if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4276         return SetStep(BO->getRHS(), !IsAdd);
4277       if (IsAdd && GetInitLCDecl(BO->getRHS()) == LCDecl)
4278         return SetStep(BO->getLHS(), false);
4279     }
4280   } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(RHS)) {
4281     bool IsAdd = CE->getOperator() == OO_Plus;
4282     if ((IsAdd || CE->getOperator() == OO_Minus) && CE->getNumArgs() == 2) {
4283       if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4284         return SetStep(CE->getArg(1), !IsAdd);
4285       if (IsAdd && GetInitLCDecl(CE->getArg(1)) == LCDecl)
4286         return SetStep(CE->getArg(0), false);
4287     }
4288   }
4289   if (Dependent() || SemaRef.CurContext->isDependentContext())
4290     return false;
4291   SemaRef.Diag(RHS->getLocStart(), diag::err_omp_loop_not_canonical_incr)
4292       << RHS->getSourceRange() << LCDecl;
4293   return true;
4294 }
4295 
CheckInc(Expr * S)4296 bool OpenMPIterationSpaceChecker::CheckInc(Expr *S) {
4297   // Check incr-expr for canonical loop form and return true if it
4298   // does not conform.
4299   // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
4300   //   ++var
4301   //   var++
4302   //   --var
4303   //   var--
4304   //   var += incr
4305   //   var -= incr
4306   //   var = var + incr
4307   //   var = incr + var
4308   //   var = var - incr
4309   //
4310   if (!S) {
4311     SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_incr) << LCDecl;
4312     return true;
4313   }
4314   if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
4315     if (!ExprTemp->cleanupsHaveSideEffects())
4316       S = ExprTemp->getSubExpr();
4317 
4318   IncrementSrcRange = S->getSourceRange();
4319   S = S->IgnoreParens();
4320   if (auto UO = dyn_cast<UnaryOperator>(S)) {
4321     if (UO->isIncrementDecrementOp() &&
4322         GetInitLCDecl(UO->getSubExpr()) == LCDecl)
4323       return SetStep(
4324           SemaRef.ActOnIntegerConstant(UO->getLocStart(),
4325                                        (UO->isDecrementOp() ? -1 : 1)).get(),
4326           false);
4327   } else if (auto BO = dyn_cast<BinaryOperator>(S)) {
4328     switch (BO->getOpcode()) {
4329     case BO_AddAssign:
4330     case BO_SubAssign:
4331       if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4332         return SetStep(BO->getRHS(), BO->getOpcode() == BO_SubAssign);
4333       break;
4334     case BO_Assign:
4335       if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4336         return CheckIncRHS(BO->getRHS());
4337       break;
4338     default:
4339       break;
4340     }
4341   } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) {
4342     switch (CE->getOperator()) {
4343     case OO_PlusPlus:
4344     case OO_MinusMinus:
4345       if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4346         return SetStep(
4347             SemaRef.ActOnIntegerConstant(
4348                         CE->getLocStart(),
4349                         ((CE->getOperator() == OO_MinusMinus) ? -1 : 1)).get(),
4350             false);
4351       break;
4352     case OO_PlusEqual:
4353     case OO_MinusEqual:
4354       if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4355         return SetStep(CE->getArg(1), CE->getOperator() == OO_MinusEqual);
4356       break;
4357     case OO_Equal:
4358       if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4359         return CheckIncRHS(CE->getArg(1));
4360       break;
4361     default:
4362       break;
4363     }
4364   }
4365   if (Dependent() || SemaRef.CurContext->isDependentContext())
4366     return false;
4367   SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_incr)
4368       << S->getSourceRange() << LCDecl;
4369   return true;
4370 }
4371 
4372 static ExprResult
tryBuildCapture(Sema & SemaRef,Expr * Capture,llvm::MapVector<Expr *,DeclRefExpr * > & Captures)4373 tryBuildCapture(Sema &SemaRef, Expr *Capture,
4374                 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4375   if (SemaRef.CurContext->isDependentContext())
4376     return ExprResult(Capture);
4377   if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects))
4378     return SemaRef.PerformImplicitConversion(
4379         Capture->IgnoreImpCasts(), Capture->getType(), Sema::AA_Converting,
4380         /*AllowExplicit=*/true);
4381   auto I = Captures.find(Capture);
4382   if (I != Captures.end())
4383     return buildCapture(SemaRef, Capture, I->second);
4384   DeclRefExpr *Ref = nullptr;
4385   ExprResult Res = buildCapture(SemaRef, Capture, Ref);
4386   Captures[Capture] = Ref;
4387   return Res;
4388 }
4389 
4390 /// \brief Build the expression to calculate the number of iterations.
BuildNumIterations(Scope * S,const bool LimitedType,llvm::MapVector<Expr *,DeclRefExpr * > & Captures) const4391 Expr *OpenMPIterationSpaceChecker::BuildNumIterations(
4392     Scope *S, const bool LimitedType,
4393     llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
4394   ExprResult Diff;
4395   auto VarType = LCDecl->getType().getNonReferenceType();
4396   if (VarType->isIntegerType() || VarType->isPointerType() ||
4397       SemaRef.getLangOpts().CPlusPlus) {
4398     // Upper - Lower
4399     auto *UBExpr = TestIsLessOp ? UB : LB;
4400     auto *LBExpr = TestIsLessOp ? LB : UB;
4401     Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get();
4402     Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get();
4403     if (!Upper || !Lower)
4404       return nullptr;
4405 
4406     Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Sub, Upper, Lower);
4407 
4408     if (!Diff.isUsable() && VarType->getAsCXXRecordDecl()) {
4409       // BuildBinOp already emitted error, this one is to point user to upper
4410       // and lower bound, and to tell what is passed to 'operator-'.
4411       SemaRef.Diag(Upper->getLocStart(), diag::err_omp_loop_diff_cxx)
4412           << Upper->getSourceRange() << Lower->getSourceRange();
4413       return nullptr;
4414     }
4415   }
4416 
4417   if (!Diff.isUsable())
4418     return nullptr;
4419 
4420   // Upper - Lower [- 1]
4421   if (TestIsStrictOp)
4422     Diff = SemaRef.BuildBinOp(
4423         S, DefaultLoc, BO_Sub, Diff.get(),
4424         SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
4425   if (!Diff.isUsable())
4426     return nullptr;
4427 
4428   // Upper - Lower [- 1] + Step
4429   auto NewStep = tryBuildCapture(SemaRef, Step, Captures);
4430   if (!NewStep.isUsable())
4431     return nullptr;
4432   Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Add, Diff.get(), NewStep.get());
4433   if (!Diff.isUsable())
4434     return nullptr;
4435 
4436   // Parentheses (for dumping/debugging purposes only).
4437   Diff = SemaRef.ActOnParenExpr(DefaultLoc, DefaultLoc, Diff.get());
4438   if (!Diff.isUsable())
4439     return nullptr;
4440 
4441   // (Upper - Lower [- 1] + Step) / Step
4442   Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Div, Diff.get(), NewStep.get());
4443   if (!Diff.isUsable())
4444     return nullptr;
4445 
4446   // OpenMP runtime requires 32-bit or 64-bit loop variables.
4447   QualType Type = Diff.get()->getType();
4448   auto &C = SemaRef.Context;
4449   bool UseVarType = VarType->hasIntegerRepresentation() &&
4450                     C.getTypeSize(Type) > C.getTypeSize(VarType);
4451   if (!Type->isIntegerType() || UseVarType) {
4452     unsigned NewSize =
4453         UseVarType ? C.getTypeSize(VarType) : C.getTypeSize(Type);
4454     bool IsSigned = UseVarType ? VarType->hasSignedIntegerRepresentation()
4455                                : Type->hasSignedIntegerRepresentation();
4456     Type = C.getIntTypeForBitwidth(NewSize, IsSigned);
4457     if (!SemaRef.Context.hasSameType(Diff.get()->getType(), Type)) {
4458       Diff = SemaRef.PerformImplicitConversion(
4459           Diff.get(), Type, Sema::AA_Converting, /*AllowExplicit=*/true);
4460       if (!Diff.isUsable())
4461         return nullptr;
4462     }
4463   }
4464   if (LimitedType) {
4465     unsigned NewSize = (C.getTypeSize(Type) > 32) ? 64 : 32;
4466     if (NewSize != C.getTypeSize(Type)) {
4467       if (NewSize < C.getTypeSize(Type)) {
4468         assert(NewSize == 64 && "incorrect loop var size");
4469         SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var)
4470             << InitSrcRange << ConditionSrcRange;
4471       }
4472       QualType NewType = C.getIntTypeForBitwidth(
4473           NewSize, Type->hasSignedIntegerRepresentation() ||
4474                        C.getTypeSize(Type) < NewSize);
4475       if (!SemaRef.Context.hasSameType(Diff.get()->getType(), NewType)) {
4476         Diff = SemaRef.PerformImplicitConversion(Diff.get(), NewType,
4477                                                  Sema::AA_Converting, true);
4478         if (!Diff.isUsable())
4479           return nullptr;
4480       }
4481     }
4482   }
4483 
4484   return Diff.get();
4485 }
4486 
BuildPreCond(Scope * S,Expr * Cond,llvm::MapVector<Expr *,DeclRefExpr * > & Captures) const4487 Expr *OpenMPIterationSpaceChecker::BuildPreCond(
4488     Scope *S, Expr *Cond,
4489     llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
4490   // Try to build LB <op> UB, where <op> is <, >, <=, or >=.
4491   bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
4492   SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
4493 
4494   auto NewLB = tryBuildCapture(SemaRef, LB, Captures);
4495   auto NewUB = tryBuildCapture(SemaRef, UB, Captures);
4496   if (!NewLB.isUsable() || !NewUB.isUsable())
4497     return nullptr;
4498 
4499   auto CondExpr = SemaRef.BuildBinOp(
4500       S, DefaultLoc, TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE)
4501                                   : (TestIsStrictOp ? BO_GT : BO_GE),
4502       NewLB.get(), NewUB.get());
4503   if (CondExpr.isUsable()) {
4504     if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(),
4505                                                 SemaRef.Context.BoolTy))
4506       CondExpr = SemaRef.PerformImplicitConversion(
4507           CondExpr.get(), SemaRef.Context.BoolTy, /*Action=*/Sema::AA_Casting,
4508           /*AllowExplicit=*/true);
4509   }
4510   SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
4511   // Otherwise use original loop conditon and evaluate it in runtime.
4512   return CondExpr.isUsable() ? CondExpr.get() : Cond;
4513 }
4514 
4515 /// \brief Build reference expression to the counter be used for codegen.
BuildCounterVar(llvm::MapVector<Expr *,DeclRefExpr * > & Captures,DSAStackTy & DSA) const4516 DeclRefExpr *OpenMPIterationSpaceChecker::BuildCounterVar(
4517     llvm::MapVector<Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const {
4518   auto *VD = dyn_cast<VarDecl>(LCDecl);
4519   if (!VD) {
4520     VD = SemaRef.IsOpenMPCapturedDecl(LCDecl);
4521     auto *Ref = buildDeclRefExpr(
4522         SemaRef, VD, VD->getType().getNonReferenceType(), DefaultLoc);
4523     DSAStackTy::DSAVarData Data = DSA.getTopDSA(LCDecl, /*FromParent=*/false);
4524     // If the loop control decl is explicitly marked as private, do not mark it
4525     // as captured again.
4526     if (!isOpenMPPrivate(Data.CKind) || !Data.RefExpr)
4527       Captures.insert(std::make_pair(LCRef, Ref));
4528     return Ref;
4529   }
4530   return buildDeclRefExpr(SemaRef, VD, VD->getType().getNonReferenceType(),
4531                           DefaultLoc);
4532 }
4533 
BuildPrivateCounterVar() const4534 Expr *OpenMPIterationSpaceChecker::BuildPrivateCounterVar() const {
4535   if (LCDecl && !LCDecl->isInvalidDecl()) {
4536     auto Type = LCDecl->getType().getNonReferenceType();
4537     auto *PrivateVar =
4538         buildVarDecl(SemaRef, DefaultLoc, Type, LCDecl->getName(),
4539                      LCDecl->hasAttrs() ? &LCDecl->getAttrs() : nullptr);
4540     if (PrivateVar->isInvalidDecl())
4541       return nullptr;
4542     return buildDeclRefExpr(SemaRef, PrivateVar, Type, DefaultLoc);
4543   }
4544   return nullptr;
4545 }
4546 
4547 /// \brief Build initization of the counter be used for codegen.
BuildCounterInit() const4548 Expr *OpenMPIterationSpaceChecker::BuildCounterInit() const { return LB; }
4549 
4550 /// \brief Build step of the counter be used for codegen.
BuildCounterStep() const4551 Expr *OpenMPIterationSpaceChecker::BuildCounterStep() const { return Step; }
4552 
4553 /// \brief Iteration space of a single for loop.
4554 struct LoopIterationSpace final {
4555   /// \brief Condition of the loop.
4556   Expr *PreCond = nullptr;
4557   /// \brief This expression calculates the number of iterations in the loop.
4558   /// It is always possible to calculate it before starting the loop.
4559   Expr *NumIterations = nullptr;
4560   /// \brief The loop counter variable.
4561   Expr *CounterVar = nullptr;
4562   /// \brief Private loop counter variable.
4563   Expr *PrivateCounterVar = nullptr;
4564   /// \brief This is initializer for the initial value of #CounterVar.
4565   Expr *CounterInit = nullptr;
4566   /// \brief This is step for the #CounterVar used to generate its update:
4567   /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration.
4568   Expr *CounterStep = nullptr;
4569   /// \brief Should step be subtracted?
4570   bool Subtract = false;
4571   /// \brief Source range of the loop init.
4572   SourceRange InitSrcRange;
4573   /// \brief Source range of the loop condition.
4574   SourceRange CondSrcRange;
4575   /// \brief Source range of the loop increment.
4576   SourceRange IncSrcRange;
4577 };
4578 
4579 } // namespace
4580 
ActOnOpenMPLoopInitialization(SourceLocation ForLoc,Stmt * Init)4581 void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) {
4582   assert(getLangOpts().OpenMP && "OpenMP is not active.");
4583   assert(Init && "Expected loop in canonical form.");
4584   unsigned AssociatedLoops = DSAStack->getAssociatedLoops();
4585   if (AssociatedLoops > 0 &&
4586       isOpenMPLoopDirective(DSAStack->getCurrentDirective())) {
4587     OpenMPIterationSpaceChecker ISC(*this, ForLoc);
4588     if (!ISC.CheckInit(Init, /*EmitDiags=*/false)) {
4589       if (auto *D = ISC.GetLoopDecl()) {
4590         auto *VD = dyn_cast<VarDecl>(D);
4591         if (!VD) {
4592           if (auto *Private = IsOpenMPCapturedDecl(D))
4593             VD = Private;
4594           else {
4595             auto *Ref = buildCapture(*this, D, ISC.GetLoopDeclRefExpr(),
4596                                      /*WithInit=*/false);
4597             VD = cast<VarDecl>(Ref->getDecl());
4598           }
4599         }
4600         DSAStack->addLoopControlVariable(D, VD);
4601       }
4602     }
4603     DSAStack->setAssociatedLoops(AssociatedLoops - 1);
4604   }
4605 }
4606 
4607 /// \brief Called on a for stmt to check and extract its iteration space
4608 /// for further processing (such as collapsing).
CheckOpenMPIterationSpace(OpenMPDirectiveKind DKind,Stmt * S,Sema & SemaRef,DSAStackTy & DSA,unsigned CurrentNestedLoopCount,unsigned NestedLoopCount,Expr * CollapseLoopCountExpr,Expr * OrderedLoopCountExpr,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA,LoopIterationSpace & ResultIterSpace,llvm::MapVector<Expr *,DeclRefExpr * > & Captures)4609 static bool CheckOpenMPIterationSpace(
4610     OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA,
4611     unsigned CurrentNestedLoopCount, unsigned NestedLoopCount,
4612     Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr,
4613     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
4614     LoopIterationSpace &ResultIterSpace,
4615     llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4616   // OpenMP [2.6, Canonical Loop Form]
4617   //   for (init-expr; test-expr; incr-expr) structured-block
4618   auto For = dyn_cast_or_null<ForStmt>(S);
4619   if (!For) {
4620     SemaRef.Diag(S->getLocStart(), diag::err_omp_not_for)
4621         << (CollapseLoopCountExpr != nullptr || OrderedLoopCountExpr != nullptr)
4622         << getOpenMPDirectiveName(DKind) << NestedLoopCount
4623         << (CurrentNestedLoopCount > 0) << CurrentNestedLoopCount;
4624     if (NestedLoopCount > 1) {
4625       if (CollapseLoopCountExpr && OrderedLoopCountExpr)
4626         SemaRef.Diag(DSA.getConstructLoc(),
4627                      diag::note_omp_collapse_ordered_expr)
4628             << 2 << CollapseLoopCountExpr->getSourceRange()
4629             << OrderedLoopCountExpr->getSourceRange();
4630       else if (CollapseLoopCountExpr)
4631         SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
4632                      diag::note_omp_collapse_ordered_expr)
4633             << 0 << CollapseLoopCountExpr->getSourceRange();
4634       else
4635         SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
4636                      diag::note_omp_collapse_ordered_expr)
4637             << 1 << OrderedLoopCountExpr->getSourceRange();
4638     }
4639     return true;
4640   }
4641   assert(For->getBody());
4642 
4643   OpenMPIterationSpaceChecker ISC(SemaRef, For->getForLoc());
4644 
4645   // Check init.
4646   auto Init = For->getInit();
4647   if (ISC.CheckInit(Init))
4648     return true;
4649 
4650   bool HasErrors = false;
4651 
4652   // Check loop variable's type.
4653   if (auto *LCDecl = ISC.GetLoopDecl()) {
4654     auto *LoopDeclRefExpr = ISC.GetLoopDeclRefExpr();
4655 
4656     // OpenMP [2.6, Canonical Loop Form]
4657     // Var is one of the following:
4658     //   A variable of signed or unsigned integer type.
4659     //   For C++, a variable of a random access iterator type.
4660     //   For C, a variable of a pointer type.
4661     auto VarType = LCDecl->getType().getNonReferenceType();
4662     if (!VarType->isDependentType() && !VarType->isIntegerType() &&
4663         !VarType->isPointerType() &&
4664         !(SemaRef.getLangOpts().CPlusPlus && VarType->isOverloadableType())) {
4665       SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_variable_type)
4666           << SemaRef.getLangOpts().CPlusPlus;
4667       HasErrors = true;
4668     }
4669 
4670     // OpenMP, 2.14.1.1 Data-sharing Attribute Rules for Variables Referenced in
4671     // a Construct
4672     // The loop iteration variable(s) in the associated for-loop(s) of a for or
4673     // parallel for construct is (are) private.
4674     // The loop iteration variable in the associated for-loop of a simd
4675     // construct with just one associated for-loop is linear with a
4676     // constant-linear-step that is the increment of the associated for-loop.
4677     // Exclude loop var from the list of variables with implicitly defined data
4678     // sharing attributes.
4679     VarsWithImplicitDSA.erase(LCDecl);
4680 
4681     // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
4682     // in a Construct, C/C++].
4683     // The loop iteration variable in the associated for-loop of a simd
4684     // construct with just one associated for-loop may be listed in a linear
4685     // clause with a constant-linear-step that is the increment of the
4686     // associated for-loop.
4687     // The loop iteration variable(s) in the associated for-loop(s) of a for or
4688     // parallel for construct may be listed in a private or lastprivate clause.
4689     DSAStackTy::DSAVarData DVar = DSA.getTopDSA(LCDecl, false);
4690     // If LoopVarRefExpr is nullptr it means the corresponding loop variable is
4691     // declared in the loop and it is predetermined as a private.
4692     auto PredeterminedCKind =
4693         isOpenMPSimdDirective(DKind)
4694             ? ((NestedLoopCount == 1) ? OMPC_linear : OMPC_lastprivate)
4695             : OMPC_private;
4696     if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
4697           DVar.CKind != PredeterminedCKind) ||
4698          ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop ||
4699            isOpenMPDistributeDirective(DKind)) &&
4700           !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
4701           DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) &&
4702         (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
4703       SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_var_dsa)
4704           << getOpenMPClauseName(DVar.CKind) << getOpenMPDirectiveName(DKind)
4705           << getOpenMPClauseName(PredeterminedCKind);
4706       if (DVar.RefExpr == nullptr)
4707         DVar.CKind = PredeterminedCKind;
4708       ReportOriginalDSA(SemaRef, &DSA, LCDecl, DVar, /*IsLoopIterVar=*/true);
4709       HasErrors = true;
4710     } else if (LoopDeclRefExpr != nullptr) {
4711       // Make the loop iteration variable private (for worksharing constructs),
4712       // linear (for simd directives with the only one associated loop) or
4713       // lastprivate (for simd directives with several collapsed or ordered
4714       // loops).
4715       if (DVar.CKind == OMPC_unknown)
4716         DVar = DSA.hasDSA(LCDecl, isOpenMPPrivate,
4717                           [](OpenMPDirectiveKind) -> bool { return true; },
4718                           /*FromParent=*/false);
4719       DSA.addDSA(LCDecl, LoopDeclRefExpr, PredeterminedCKind);
4720     }
4721 
4722     assert(isOpenMPLoopDirective(DKind) && "DSA for non-loop vars");
4723 
4724     // Check test-expr.
4725     HasErrors |= ISC.CheckCond(For->getCond());
4726 
4727     // Check incr-expr.
4728     HasErrors |= ISC.CheckInc(For->getInc());
4729   }
4730 
4731   if (ISC.Dependent() || SemaRef.CurContext->isDependentContext() || HasErrors)
4732     return HasErrors;
4733 
4734   // Build the loop's iteration space representation.
4735   ResultIterSpace.PreCond =
4736       ISC.BuildPreCond(DSA.getCurScope(), For->getCond(), Captures);
4737   ResultIterSpace.NumIterations = ISC.BuildNumIterations(
4738       DSA.getCurScope(),
4739       (isOpenMPWorksharingDirective(DKind) ||
4740        isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)),
4741       Captures);
4742   ResultIterSpace.CounterVar = ISC.BuildCounterVar(Captures, DSA);
4743   ResultIterSpace.PrivateCounterVar = ISC.BuildPrivateCounterVar();
4744   ResultIterSpace.CounterInit = ISC.BuildCounterInit();
4745   ResultIterSpace.CounterStep = ISC.BuildCounterStep();
4746   ResultIterSpace.InitSrcRange = ISC.GetInitSrcRange();
4747   ResultIterSpace.CondSrcRange = ISC.GetConditionSrcRange();
4748   ResultIterSpace.IncSrcRange = ISC.GetIncrementSrcRange();
4749   ResultIterSpace.Subtract = ISC.ShouldSubtractStep();
4750 
4751   HasErrors |= (ResultIterSpace.PreCond == nullptr ||
4752                 ResultIterSpace.NumIterations == nullptr ||
4753                 ResultIterSpace.CounterVar == nullptr ||
4754                 ResultIterSpace.PrivateCounterVar == nullptr ||
4755                 ResultIterSpace.CounterInit == nullptr ||
4756                 ResultIterSpace.CounterStep == nullptr);
4757 
4758   return HasErrors;
4759 }
4760 
4761 /// \brief Build 'VarRef = Start.
4762 static ExprResult
BuildCounterInit(Sema & SemaRef,Scope * S,SourceLocation Loc,ExprResult VarRef,ExprResult Start,llvm::MapVector<Expr *,DeclRefExpr * > & Captures)4763 BuildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef,
4764                  ExprResult Start,
4765                  llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4766   // Build 'VarRef = Start.
4767   auto NewStart = tryBuildCapture(SemaRef, Start.get(), Captures);
4768   if (!NewStart.isUsable())
4769     return ExprError();
4770   if (!SemaRef.Context.hasSameType(NewStart.get()->getType(),
4771                                    VarRef.get()->getType())) {
4772     NewStart = SemaRef.PerformImplicitConversion(
4773         NewStart.get(), VarRef.get()->getType(), Sema::AA_Converting,
4774         /*AllowExplicit=*/true);
4775     if (!NewStart.isUsable())
4776       return ExprError();
4777   }
4778 
4779   auto Init =
4780       SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
4781   return Init;
4782 }
4783 
4784 /// \brief Build 'VarRef = Start + Iter * Step'.
4785 static ExprResult
BuildCounterUpdate(Sema & SemaRef,Scope * S,SourceLocation Loc,ExprResult VarRef,ExprResult Start,ExprResult Iter,ExprResult Step,bool Subtract,llvm::MapVector<Expr *,DeclRefExpr * > * Captures=nullptr)4786 BuildCounterUpdate(Sema &SemaRef, Scope *S, SourceLocation Loc,
4787                    ExprResult VarRef, ExprResult Start, ExprResult Iter,
4788                    ExprResult Step, bool Subtract,
4789                    llvm::MapVector<Expr *, DeclRefExpr *> *Captures = nullptr) {
4790   // Add parentheses (for debugging purposes only).
4791   Iter = SemaRef.ActOnParenExpr(Loc, Loc, Iter.get());
4792   if (!VarRef.isUsable() || !Start.isUsable() || !Iter.isUsable() ||
4793       !Step.isUsable())
4794     return ExprError();
4795 
4796   ExprResult NewStep = Step;
4797   if (Captures)
4798     NewStep = tryBuildCapture(SemaRef, Step.get(), *Captures);
4799   if (NewStep.isInvalid())
4800     return ExprError();
4801   ExprResult Update =
4802       SemaRef.BuildBinOp(S, Loc, BO_Mul, Iter.get(), NewStep.get());
4803   if (!Update.isUsable())
4804     return ExprError();
4805 
4806   // Try to build 'VarRef = Start, VarRef (+|-)= Iter * Step' or
4807   // 'VarRef = Start (+|-) Iter * Step'.
4808   ExprResult NewStart = Start;
4809   if (Captures)
4810     NewStart = tryBuildCapture(SemaRef, Start.get(), *Captures);
4811   if (NewStart.isInvalid())
4812     return ExprError();
4813 
4814   // First attempt: try to build 'VarRef = Start, VarRef += Iter * Step'.
4815   ExprResult SavedUpdate = Update;
4816   ExprResult UpdateVal;
4817   if (VarRef.get()->getType()->isOverloadableType() ||
4818       NewStart.get()->getType()->isOverloadableType() ||
4819       Update.get()->getType()->isOverloadableType()) {
4820     bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
4821     SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
4822     Update =
4823         SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
4824     if (Update.isUsable()) {
4825       UpdateVal =
4826           SemaRef.BuildBinOp(S, Loc, Subtract ? BO_SubAssign : BO_AddAssign,
4827                              VarRef.get(), SavedUpdate.get());
4828       if (UpdateVal.isUsable()) {
4829         Update = SemaRef.CreateBuiltinBinOp(Loc, BO_Comma, Update.get(),
4830                                             UpdateVal.get());
4831       }
4832     }
4833     SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
4834   }
4835 
4836   // Second attempt: try to build 'VarRef = Start (+|-) Iter * Step'.
4837   if (!Update.isUsable() || !UpdateVal.isUsable()) {
4838     Update = SemaRef.BuildBinOp(S, Loc, Subtract ? BO_Sub : BO_Add,
4839                                 NewStart.get(), SavedUpdate.get());
4840     if (!Update.isUsable())
4841       return ExprError();
4842 
4843     if (!SemaRef.Context.hasSameType(Update.get()->getType(),
4844                                      VarRef.get()->getType())) {
4845       Update = SemaRef.PerformImplicitConversion(
4846           Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true);
4847       if (!Update.isUsable())
4848         return ExprError();
4849     }
4850 
4851     Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get());
4852   }
4853   return Update;
4854 }
4855 
4856 /// \brief Convert integer expression \a E to make it have at least \a Bits
4857 /// bits.
WidenIterationCount(unsigned Bits,Expr * E,Sema & SemaRef)4858 static ExprResult WidenIterationCount(unsigned Bits, Expr *E,
4859                                       Sema &SemaRef) {
4860   if (E == nullptr)
4861     return ExprError();
4862   auto &C = SemaRef.Context;
4863   QualType OldType = E->getType();
4864   unsigned HasBits = C.getTypeSize(OldType);
4865   if (HasBits >= Bits)
4866     return ExprResult(E);
4867   // OK to convert to signed, because new type has more bits than old.
4868   QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
4869   return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
4870                                            true);
4871 }
4872 
4873 /// \brief Check if the given expression \a E is a constant integer that fits
4874 /// into \a Bits bits.
FitsInto(unsigned Bits,bool Signed,Expr * E,Sema & SemaRef)4875 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
4876   if (E == nullptr)
4877     return false;
4878   llvm::APSInt Result;
4879   if (E->isIntegerConstantExpr(Result, SemaRef.Context))
4880     return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits);
4881   return false;
4882 }
4883 
4884 /// Build preinits statement for the given declarations.
buildPreInits(ASTContext & Context,SmallVectorImpl<Decl * > & PreInits)4885 static Stmt *buildPreInits(ASTContext &Context,
4886                            SmallVectorImpl<Decl *> &PreInits) {
4887   if (!PreInits.empty()) {
4888     return new (Context) DeclStmt(
4889         DeclGroupRef::Create(Context, PreInits.begin(), PreInits.size()),
4890         SourceLocation(), SourceLocation());
4891   }
4892   return nullptr;
4893 }
4894 
4895 /// Build preinits statement for the given declarations.
buildPreInits(ASTContext & Context,llvm::MapVector<Expr *,DeclRefExpr * > & Captures)4896 static Stmt *buildPreInits(ASTContext &Context,
4897                            llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4898   if (!Captures.empty()) {
4899     SmallVector<Decl *, 16> PreInits;
4900     for (auto &Pair : Captures)
4901       PreInits.push_back(Pair.second->getDecl());
4902     return buildPreInits(Context, PreInits);
4903   }
4904   return nullptr;
4905 }
4906 
4907 /// Build postupdate expression for the given list of postupdates expressions.
buildPostUpdate(Sema & S,ArrayRef<Expr * > PostUpdates)4908 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
4909   Expr *PostUpdate = nullptr;
4910   if (!PostUpdates.empty()) {
4911     for (auto *E : PostUpdates) {
4912       Expr *ConvE = S.BuildCStyleCastExpr(
4913                          E->getExprLoc(),
4914                          S.Context.getTrivialTypeSourceInfo(S.Context.VoidTy),
4915                          E->getExprLoc(), E)
4916                         .get();
4917       PostUpdate = PostUpdate
4918                        ? S.CreateBuiltinBinOp(ConvE->getExprLoc(), BO_Comma,
4919                                               PostUpdate, ConvE)
4920                              .get()
4921                        : ConvE;
4922     }
4923   }
4924   return PostUpdate;
4925 }
4926 
4927 /// \brief Called on a for stmt to check itself and nested loops (if any).
4928 /// \return Returns 0 if one of the collapsed stmts is not canonical for loop,
4929 /// number of collapsed loops otherwise.
4930 static unsigned
CheckOpenMPLoop(OpenMPDirectiveKind DKind,Expr * CollapseLoopCountExpr,Expr * OrderedLoopCountExpr,Stmt * AStmt,Sema & SemaRef,DSAStackTy & DSA,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA,OMPLoopDirective::HelperExprs & Built)4931 CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
4932                 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
4933                 DSAStackTy &DSA,
4934                 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
4935                 OMPLoopDirective::HelperExprs &Built) {
4936   unsigned NestedLoopCount = 1;
4937   if (CollapseLoopCountExpr) {
4938     // Found 'collapse' clause - calculate collapse number.
4939     llvm::APSInt Result;
4940     if (CollapseLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext()))
4941       NestedLoopCount = Result.getLimitedValue();
4942   }
4943   if (OrderedLoopCountExpr) {
4944     // Found 'ordered' clause - calculate collapse number.
4945     llvm::APSInt Result;
4946     if (OrderedLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) {
4947       if (Result.getLimitedValue() < NestedLoopCount) {
4948         SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
4949                      diag::err_omp_wrong_ordered_loop_count)
4950             << OrderedLoopCountExpr->getSourceRange();
4951         SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
4952                      diag::note_collapse_loop_count)
4953             << CollapseLoopCountExpr->getSourceRange();
4954       }
4955       NestedLoopCount = Result.getLimitedValue();
4956     }
4957   }
4958   // This is helper routine for loop directives (e.g., 'for', 'simd',
4959   // 'for simd', etc.).
4960   llvm::MapVector<Expr *, DeclRefExpr *> Captures;
4961   SmallVector<LoopIterationSpace, 4> IterSpaces;
4962   IterSpaces.resize(NestedLoopCount);
4963   Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true);
4964   for (unsigned Cnt = 0; Cnt < NestedLoopCount; ++Cnt) {
4965     if (CheckOpenMPIterationSpace(DKind, CurStmt, SemaRef, DSA, Cnt,
4966                                   NestedLoopCount, CollapseLoopCountExpr,
4967                                   OrderedLoopCountExpr, VarsWithImplicitDSA,
4968                                   IterSpaces[Cnt], Captures))
4969       return 0;
4970     // Move on to the next nested for loop, or to the loop body.
4971     // OpenMP [2.8.1, simd construct, Restrictions]
4972     // All loops associated with the construct must be perfectly nested; that
4973     // is, there must be no intervening code nor any OpenMP directive between
4974     // any two loops.
4975     CurStmt = cast<ForStmt>(CurStmt)->getBody()->IgnoreContainers();
4976   }
4977 
4978   Built.clear(/* size */ NestedLoopCount);
4979 
4980   if (SemaRef.CurContext->isDependentContext())
4981     return NestedLoopCount;
4982 
4983   // An example of what is generated for the following code:
4984   //
4985   //   #pragma omp simd collapse(2) ordered(2)
4986   //   for (i = 0; i < NI; ++i)
4987   //     for (k = 0; k < NK; ++k)
4988   //       for (j = J0; j < NJ; j+=2) {
4989   //         <loop body>
4990   //       }
4991   //
4992   // We generate the code below.
4993   // Note: the loop body may be outlined in CodeGen.
4994   // Note: some counters may be C++ classes, operator- is used to find number of
4995   // iterations and operator+= to calculate counter value.
4996   // Note: decltype(NumIterations) must be integer type (in 'omp for', only i32
4997   // or i64 is currently supported).
4998   //
4999   //   #define NumIterations (NI * ((NJ - J0 - 1 + 2) / 2))
5000   //   for (int[32|64]_t IV = 0; IV < NumIterations; ++IV ) {
5001   //     .local.i = IV / ((NJ - J0 - 1 + 2) / 2);
5002   //     .local.j = J0 + (IV % ((NJ - J0 - 1 + 2) / 2)) * 2;
5003   //     // similar updates for vars in clauses (e.g. 'linear')
5004   //     <loop body (using local i and j)>
5005   //   }
5006   //   i = NI; // assign final values of counters
5007   //   j = NJ;
5008   //
5009 
5010   // Last iteration number is (I1 * I2 * ... In) - 1, where I1, I2 ... In are
5011   // the iteration counts of the collapsed for loops.
5012   // Precondition tests if there is at least one iteration (all conditions are
5013   // true).
5014   auto PreCond = ExprResult(IterSpaces[0].PreCond);
5015   auto N0 = IterSpaces[0].NumIterations;
5016   ExprResult LastIteration32 = WidenIterationCount(
5017       32 /* Bits */, SemaRef.PerformImplicitConversion(
5018                                 N0->IgnoreImpCasts(), N0->getType(),
5019                                 Sema::AA_Converting, /*AllowExplicit=*/true)
5020                          .get(),
5021       SemaRef);
5022   ExprResult LastIteration64 = WidenIterationCount(
5023       64 /* Bits */, SemaRef.PerformImplicitConversion(
5024                                 N0->IgnoreImpCasts(), N0->getType(),
5025                                 Sema::AA_Converting, /*AllowExplicit=*/true)
5026                          .get(),
5027       SemaRef);
5028 
5029   if (!LastIteration32.isUsable() || !LastIteration64.isUsable())
5030     return NestedLoopCount;
5031 
5032   auto &C = SemaRef.Context;
5033   bool AllCountsNeedLessThan32Bits = C.getTypeSize(N0->getType()) < 32;
5034 
5035   Scope *CurScope = DSA.getCurScope();
5036   for (unsigned Cnt = 1; Cnt < NestedLoopCount; ++Cnt) {
5037     if (PreCond.isUsable()) {
5038       PreCond = SemaRef.BuildBinOp(CurScope, SourceLocation(), BO_LAnd,
5039                                    PreCond.get(), IterSpaces[Cnt].PreCond);
5040     }
5041     auto N = IterSpaces[Cnt].NumIterations;
5042     AllCountsNeedLessThan32Bits &= C.getTypeSize(N->getType()) < 32;
5043     if (LastIteration32.isUsable())
5044       LastIteration32 = SemaRef.BuildBinOp(
5045           CurScope, SourceLocation(), BO_Mul, LastIteration32.get(),
5046           SemaRef.PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
5047                                             Sema::AA_Converting,
5048                                             /*AllowExplicit=*/true)
5049               .get());
5050     if (LastIteration64.isUsable())
5051       LastIteration64 = SemaRef.BuildBinOp(
5052           CurScope, SourceLocation(), BO_Mul, LastIteration64.get(),
5053           SemaRef.PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
5054                                             Sema::AA_Converting,
5055                                             /*AllowExplicit=*/true)
5056               .get());
5057   }
5058 
5059   // Choose either the 32-bit or 64-bit version.
5060   ExprResult LastIteration = LastIteration64;
5061   if (LastIteration32.isUsable() &&
5062       C.getTypeSize(LastIteration32.get()->getType()) == 32 &&
5063       (AllCountsNeedLessThan32Bits || NestedLoopCount == 1 ||
5064        FitsInto(
5065            32 /* Bits */,
5066            LastIteration32.get()->getType()->hasSignedIntegerRepresentation(),
5067            LastIteration64.get(), SemaRef)))
5068     LastIteration = LastIteration32;
5069   QualType VType = LastIteration.get()->getType();
5070   QualType RealVType = VType;
5071   QualType StrideVType = VType;
5072   if (isOpenMPTaskLoopDirective(DKind)) {
5073     VType =
5074         SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
5075     StrideVType =
5076         SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
5077   }
5078 
5079   if (!LastIteration.isUsable())
5080     return 0;
5081 
5082   // Save the number of iterations.
5083   ExprResult NumIterations = LastIteration;
5084   {
5085     LastIteration = SemaRef.BuildBinOp(
5086         CurScope, SourceLocation(), BO_Sub, LastIteration.get(),
5087         SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
5088     if (!LastIteration.isUsable())
5089       return 0;
5090   }
5091 
5092   // Calculate the last iteration number beforehand instead of doing this on
5093   // each iteration. Do not do this if the number of iterations may be kfold-ed.
5094   llvm::APSInt Result;
5095   bool IsConstant =
5096       LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context);
5097   ExprResult CalcLastIteration;
5098   if (!IsConstant) {
5099     ExprResult SaveRef =
5100         tryBuildCapture(SemaRef, LastIteration.get(), Captures);
5101     LastIteration = SaveRef;
5102 
5103     // Prepare SaveRef + 1.
5104     NumIterations = SemaRef.BuildBinOp(
5105         CurScope, SourceLocation(), BO_Add, SaveRef.get(),
5106         SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
5107     if (!NumIterations.isUsable())
5108       return 0;
5109   }
5110 
5111   SourceLocation InitLoc = IterSpaces[0].InitSrcRange.getBegin();
5112 
5113   // Build variables passed into runtime, nesessary for worksharing directives.
5114   ExprResult LB, UB, IL, ST, EUB, PrevLB, PrevUB;
5115   if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
5116       isOpenMPDistributeDirective(DKind)) {
5117     // Lower bound variable, initialized with zero.
5118     VarDecl *LBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.lb");
5119     LB = buildDeclRefExpr(SemaRef, LBDecl, VType, InitLoc);
5120     SemaRef.AddInitializerToDecl(
5121         LBDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
5122         /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
5123 
5124     // Upper bound variable, initialized with last iteration number.
5125     VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
5126     UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
5127     SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
5128                                  /*DirectInit*/ false,
5129                                  /*TypeMayContainAuto*/ false);
5130 
5131     // A 32-bit variable-flag where runtime returns 1 for the last iteration.
5132     // This will be used to implement clause 'lastprivate'.
5133     QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
5134     VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
5135     IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
5136     SemaRef.AddInitializerToDecl(
5137         ILDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
5138         /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
5139 
5140     // Stride variable returned by runtime (we initialize it to 1 by default).
5141     VarDecl *STDecl =
5142         buildVarDecl(SemaRef, InitLoc, StrideVType, ".omp.stride");
5143     ST = buildDeclRefExpr(SemaRef, STDecl, StrideVType, InitLoc);
5144     SemaRef.AddInitializerToDecl(
5145         STDecl, SemaRef.ActOnIntegerConstant(InitLoc, 1).get(),
5146         /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
5147 
5148     // Build expression: UB = min(UB, LastIteration)
5149     // It is nesessary for CodeGen of directives with static scheduling.
5150     ExprResult IsUBGreater = SemaRef.BuildBinOp(CurScope, InitLoc, BO_GT,
5151                                                 UB.get(), LastIteration.get());
5152     ExprResult CondOp = SemaRef.ActOnConditionalOp(
5153         InitLoc, InitLoc, IsUBGreater.get(), LastIteration.get(), UB.get());
5154     EUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, UB.get(),
5155                              CondOp.get());
5156     EUB = SemaRef.ActOnFinishFullExpr(EUB.get());
5157 
5158     // If we have a combined directive that combines 'distribute', 'for' or
5159     // 'simd' we need to be able to access the bounds of the schedule of the
5160     // enclosing region. E.g. in 'distribute parallel for' the bounds obtained
5161     // by scheduling 'distribute' have to be passed to the schedule of 'for'.
5162     if (isOpenMPLoopBoundSharingDirective(DKind)) {
5163       auto *CD = cast<CapturedStmt>(AStmt)->getCapturedDecl();
5164 
5165       // We expect to have at least 2 more parameters than the 'parallel'
5166       // directive does - the lower and upper bounds of the previous schedule.
5167       assert(CD->getNumParams() >= 4 &&
5168              "Unexpected number of parameters in loop combined directive");
5169 
5170       // Set the proper type for the bounds given what we learned from the
5171       // enclosed loops.
5172       auto *PrevLBDecl = CD->getParam(/*PrevLB=*/2);
5173       auto *PrevUBDecl = CD->getParam(/*PrevUB=*/3);
5174 
5175       // Previous lower and upper bounds are obtained from the region
5176       // parameters.
5177       PrevLB =
5178           buildDeclRefExpr(SemaRef, PrevLBDecl, PrevLBDecl->getType(), InitLoc);
5179       PrevUB =
5180           buildDeclRefExpr(SemaRef, PrevUBDecl, PrevUBDecl->getType(), InitLoc);
5181     }
5182   }
5183 
5184   // Build the iteration variable and its initialization before loop.
5185   ExprResult IV;
5186   ExprResult Init;
5187   {
5188     VarDecl *IVDecl = buildVarDecl(SemaRef, InitLoc, RealVType, ".omp.iv");
5189     IV = buildDeclRefExpr(SemaRef, IVDecl, RealVType, InitLoc);
5190     Expr *RHS = (isOpenMPWorksharingDirective(DKind) ||
5191                  isOpenMPTaskLoopDirective(DKind) ||
5192                  isOpenMPDistributeDirective(DKind))
5193                     ? LB.get()
5194                     : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
5195     Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS);
5196     Init = SemaRef.ActOnFinishFullExpr(Init.get());
5197   }
5198 
5199   // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops.
5200   SourceLocation CondLoc;
5201   ExprResult Cond =
5202       (isOpenMPWorksharingDirective(DKind) ||
5203        isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
5204           ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get())
5205           : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(),
5206                                NumIterations.get());
5207 
5208   // Loop increment (IV = IV + 1)
5209   SourceLocation IncLoc;
5210   ExprResult Inc =
5211       SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, IV.get(),
5212                          SemaRef.ActOnIntegerConstant(IncLoc, 1).get());
5213   if (!Inc.isUsable())
5214     return 0;
5215   Inc = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, IV.get(), Inc.get());
5216   Inc = SemaRef.ActOnFinishFullExpr(Inc.get());
5217   if (!Inc.isUsable())
5218     return 0;
5219 
5220   // Increments for worksharing loops (LB = LB + ST; UB = UB + ST).
5221   // Used for directives with static scheduling.
5222   ExprResult NextLB, NextUB;
5223   if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
5224       isOpenMPDistributeDirective(DKind)) {
5225     // LB + ST
5226     NextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, LB.get(), ST.get());
5227     if (!NextLB.isUsable())
5228       return 0;
5229     // LB = LB + ST
5230     NextLB =
5231         SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, LB.get(), NextLB.get());
5232     NextLB = SemaRef.ActOnFinishFullExpr(NextLB.get());
5233     if (!NextLB.isUsable())
5234       return 0;
5235     // UB + ST
5236     NextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, UB.get(), ST.get());
5237     if (!NextUB.isUsable())
5238       return 0;
5239     // UB = UB + ST
5240     NextUB =
5241         SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, UB.get(), NextUB.get());
5242     NextUB = SemaRef.ActOnFinishFullExpr(NextUB.get());
5243     if (!NextUB.isUsable())
5244       return 0;
5245   }
5246 
5247   // Build updates and final values of the loop counters.
5248   bool HasErrors = false;
5249   Built.Counters.resize(NestedLoopCount);
5250   Built.Inits.resize(NestedLoopCount);
5251   Built.Updates.resize(NestedLoopCount);
5252   Built.Finals.resize(NestedLoopCount);
5253   SmallVector<Expr *, 4> LoopMultipliers;
5254   {
5255     ExprResult Div;
5256     // Go from inner nested loop to outer.
5257     for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
5258       LoopIterationSpace &IS = IterSpaces[Cnt];
5259       SourceLocation UpdLoc = IS.IncSrcRange.getBegin();
5260       // Build: Iter = (IV / Div) % IS.NumIters
5261       // where Div is product of previous iterations' IS.NumIters.
5262       ExprResult Iter;
5263       if (Div.isUsable()) {
5264         Iter =
5265             SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Div, IV.get(), Div.get());
5266       } else {
5267         Iter = IV;
5268         assert((Cnt == (int)NestedLoopCount - 1) &&
5269                "unusable div expected on first iteration only");
5270       }
5271 
5272       if (Cnt != 0 && Iter.isUsable())
5273         Iter = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Rem, Iter.get(),
5274                                   IS.NumIterations);
5275       if (!Iter.isUsable()) {
5276         HasErrors = true;
5277         break;
5278       }
5279 
5280       // Build update: IS.CounterVar(Private) = IS.Start + Iter * IS.Step
5281       auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IS.CounterVar)->getDecl());
5282       auto *CounterVar = buildDeclRefExpr(SemaRef, VD, IS.CounterVar->getType(),
5283                                           IS.CounterVar->getExprLoc(),
5284                                           /*RefersToCapture=*/true);
5285       ExprResult Init = BuildCounterInit(SemaRef, CurScope, UpdLoc, CounterVar,
5286                                          IS.CounterInit, Captures);
5287       if (!Init.isUsable()) {
5288         HasErrors = true;
5289         break;
5290       }
5291       ExprResult Update = BuildCounterUpdate(
5292           SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, Iter,
5293           IS.CounterStep, IS.Subtract, &Captures);
5294       if (!Update.isUsable()) {
5295         HasErrors = true;
5296         break;
5297       }
5298 
5299       // Build final: IS.CounterVar = IS.Start + IS.NumIters * IS.Step
5300       ExprResult Final = BuildCounterUpdate(
5301           SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit,
5302           IS.NumIterations, IS.CounterStep, IS.Subtract, &Captures);
5303       if (!Final.isUsable()) {
5304         HasErrors = true;
5305         break;
5306       }
5307 
5308       // Build Div for the next iteration: Div <- Div * IS.NumIters
5309       if (Cnt != 0) {
5310         if (Div.isUnset())
5311           Div = IS.NumIterations;
5312         else
5313           Div = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Mul, Div.get(),
5314                                    IS.NumIterations);
5315 
5316         // Add parentheses (for debugging purposes only).
5317         if (Div.isUsable())
5318           Div = tryBuildCapture(SemaRef, Div.get(), Captures);
5319         if (!Div.isUsable()) {
5320           HasErrors = true;
5321           break;
5322         }
5323         LoopMultipliers.push_back(Div.get());
5324       }
5325       if (!Update.isUsable() || !Final.isUsable()) {
5326         HasErrors = true;
5327         break;
5328       }
5329       // Save results
5330       Built.Counters[Cnt] = IS.CounterVar;
5331       Built.PrivateCounters[Cnt] = IS.PrivateCounterVar;
5332       Built.Inits[Cnt] = Init.get();
5333       Built.Updates[Cnt] = Update.get();
5334       Built.Finals[Cnt] = Final.get();
5335     }
5336   }
5337 
5338   if (HasErrors)
5339     return 0;
5340 
5341   // Save results
5342   Built.IterationVarRef = IV.get();
5343   Built.LastIteration = LastIteration.get();
5344   Built.NumIterations = NumIterations.get();
5345   Built.CalcLastIteration =
5346       SemaRef.ActOnFinishFullExpr(CalcLastIteration.get()).get();
5347   Built.PreCond = PreCond.get();
5348   Built.PreInits = buildPreInits(C, Captures);
5349   Built.Cond = Cond.get();
5350   Built.Init = Init.get();
5351   Built.Inc = Inc.get();
5352   Built.LB = LB.get();
5353   Built.UB = UB.get();
5354   Built.IL = IL.get();
5355   Built.ST = ST.get();
5356   Built.EUB = EUB.get();
5357   Built.NLB = NextLB.get();
5358   Built.NUB = NextUB.get();
5359   Built.PrevLB = PrevLB.get();
5360   Built.PrevUB = PrevUB.get();
5361 
5362   Expr *CounterVal = SemaRef.DefaultLvalueConversion(IV.get()).get();
5363   // Fill data for doacross depend clauses.
5364   for (auto Pair : DSA.getDoacrossDependClauses()) {
5365     if (Pair.first->getDependencyKind() == OMPC_DEPEND_source)
5366       Pair.first->setCounterValue(CounterVal);
5367     else {
5368       if (NestedLoopCount != Pair.second.size() ||
5369           NestedLoopCount != LoopMultipliers.size() + 1) {
5370         // Erroneous case - clause has some problems.
5371         Pair.first->setCounterValue(CounterVal);
5372         continue;
5373       }
5374       assert(Pair.first->getDependencyKind() == OMPC_DEPEND_sink);
5375       auto I = Pair.second.rbegin();
5376       auto IS = IterSpaces.rbegin();
5377       auto ILM = LoopMultipliers.rbegin();
5378       Expr *UpCounterVal = CounterVal;
5379       Expr *Multiplier = nullptr;
5380       for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
5381         if (I->first) {
5382           assert(IS->CounterStep);
5383           Expr *NormalizedOffset =
5384               SemaRef
5385                   .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Div,
5386                               I->first, IS->CounterStep)
5387                   .get();
5388           if (Multiplier) {
5389             NormalizedOffset =
5390                 SemaRef
5391                     .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Mul,
5392                                 NormalizedOffset, Multiplier)
5393                     .get();
5394           }
5395           assert(I->second == OO_Plus || I->second == OO_Minus);
5396           BinaryOperatorKind BOK = (I->second == OO_Plus) ? BO_Add : BO_Sub;
5397           UpCounterVal =
5398               SemaRef.BuildBinOp(CurScope, I->first->getExprLoc(), BOK,
5399                                  UpCounterVal, NormalizedOffset).get();
5400         }
5401         Multiplier = *ILM;
5402         ++I;
5403         ++IS;
5404         ++ILM;
5405       }
5406       Pair.first->setCounterValue(UpCounterVal);
5407     }
5408   }
5409 
5410   return NestedLoopCount;
5411 }
5412 
getCollapseNumberExpr(ArrayRef<OMPClause * > Clauses)5413 static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) {
5414   auto CollapseClauses =
5415       OMPExecutableDirective::getClausesOfKind<OMPCollapseClause>(Clauses);
5416   if (CollapseClauses.begin() != CollapseClauses.end())
5417     return (*CollapseClauses.begin())->getNumForLoops();
5418   return nullptr;
5419 }
5420 
getOrderedNumberExpr(ArrayRef<OMPClause * > Clauses)5421 static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) {
5422   auto OrderedClauses =
5423       OMPExecutableDirective::getClausesOfKind<OMPOrderedClause>(Clauses);
5424   if (OrderedClauses.begin() != OrderedClauses.end())
5425     return (*OrderedClauses.begin())->getNumForLoops();
5426   return nullptr;
5427 }
5428 
checkSimdlenSafelenValues(Sema & S,const Expr * Simdlen,const Expr * Safelen)5429 static bool checkSimdlenSafelenValues(Sema &S, const Expr *Simdlen,
5430                                       const Expr *Safelen) {
5431   llvm::APSInt SimdlenRes, SafelenRes;
5432   if (Simdlen->isValueDependent() || Simdlen->isTypeDependent() ||
5433       Simdlen->isInstantiationDependent() ||
5434       Simdlen->containsUnexpandedParameterPack())
5435     return false;
5436   if (Safelen->isValueDependent() || Safelen->isTypeDependent() ||
5437       Safelen->isInstantiationDependent() ||
5438       Safelen->containsUnexpandedParameterPack())
5439     return false;
5440   Simdlen->EvaluateAsInt(SimdlenRes, S.Context);
5441   Safelen->EvaluateAsInt(SafelenRes, S.Context);
5442   // OpenMP 4.1 [2.8.1, simd Construct, Restrictions]
5443   // If both simdlen and safelen clauses are specified, the value of the simdlen
5444   // parameter must be less than or equal to the value of the safelen parameter.
5445   if (SimdlenRes > SafelenRes) {
5446     S.Diag(Simdlen->getExprLoc(), diag::err_omp_wrong_simdlen_safelen_values)
5447         << Simdlen->getSourceRange() << Safelen->getSourceRange();
5448     return true;
5449   }
5450   return false;
5451 }
5452 
ActOnOpenMPSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)5453 StmtResult Sema::ActOnOpenMPSimdDirective(
5454     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5455     SourceLocation EndLoc,
5456     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5457   if (!AStmt)
5458     return StmtError();
5459 
5460   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5461   OMPLoopDirective::HelperExprs B;
5462   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5463   // define the nested loops number.
5464   unsigned NestedLoopCount = CheckOpenMPLoop(
5465       OMPD_simd, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
5466       AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
5467   if (NestedLoopCount == 0)
5468     return StmtError();
5469 
5470   assert((CurContext->isDependentContext() || B.builtAll()) &&
5471          "omp simd loop exprs were not built");
5472 
5473   if (!CurContext->isDependentContext()) {
5474     // Finalize the clauses that need pre-built expressions for CodeGen.
5475     for (auto C : Clauses) {
5476       if (auto LC = dyn_cast<OMPLinearClause>(C))
5477         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5478                                      B.NumIterations, *this, CurScope,
5479                                      DSAStack))
5480           return StmtError();
5481     }
5482   }
5483 
5484   // OpenMP 4.1 [2.8.1, simd Construct, Restrictions]
5485   // If both simdlen and safelen clauses are specified, the value of the simdlen
5486   // parameter must be less than or equal to the value of the safelen parameter.
5487   OMPSafelenClause *Safelen = nullptr;
5488   OMPSimdlenClause *Simdlen = nullptr;
5489   for (auto *Clause : Clauses) {
5490     if (Clause->getClauseKind() == OMPC_safelen)
5491       Safelen = cast<OMPSafelenClause>(Clause);
5492     else if (Clause->getClauseKind() == OMPC_simdlen)
5493       Simdlen = cast<OMPSimdlenClause>(Clause);
5494     if (Safelen && Simdlen)
5495       break;
5496   }
5497   if (Simdlen && Safelen &&
5498       checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(),
5499                                 Safelen->getSafelen()))
5500     return StmtError();
5501 
5502   getCurFunction()->setHasBranchProtectedScope();
5503   return OMPSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
5504                                   Clauses, AStmt, B);
5505 }
5506 
ActOnOpenMPForDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)5507 StmtResult Sema::ActOnOpenMPForDirective(
5508     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5509     SourceLocation EndLoc,
5510     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5511   if (!AStmt)
5512     return StmtError();
5513 
5514   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5515   OMPLoopDirective::HelperExprs B;
5516   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5517   // define the nested loops number.
5518   unsigned NestedLoopCount = CheckOpenMPLoop(
5519       OMPD_for, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
5520       AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
5521   if (NestedLoopCount == 0)
5522     return StmtError();
5523 
5524   assert((CurContext->isDependentContext() || B.builtAll()) &&
5525          "omp for loop exprs were not built");
5526 
5527   if (!CurContext->isDependentContext()) {
5528     // Finalize the clauses that need pre-built expressions for CodeGen.
5529     for (auto C : Clauses) {
5530       if (auto LC = dyn_cast<OMPLinearClause>(C))
5531         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5532                                      B.NumIterations, *this, CurScope,
5533                                      DSAStack))
5534           return StmtError();
5535     }
5536   }
5537 
5538   getCurFunction()->setHasBranchProtectedScope();
5539   return OMPForDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
5540                                  Clauses, AStmt, B, DSAStack->isCancelRegion());
5541 }
5542 
ActOnOpenMPForSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)5543 StmtResult Sema::ActOnOpenMPForSimdDirective(
5544     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5545     SourceLocation EndLoc,
5546     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5547   if (!AStmt)
5548     return StmtError();
5549 
5550   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5551   OMPLoopDirective::HelperExprs B;
5552   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5553   // define the nested loops number.
5554   unsigned NestedLoopCount =
5555       CheckOpenMPLoop(OMPD_for_simd, getCollapseNumberExpr(Clauses),
5556                       getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5557                       VarsWithImplicitDSA, B);
5558   if (NestedLoopCount == 0)
5559     return StmtError();
5560 
5561   assert((CurContext->isDependentContext() || B.builtAll()) &&
5562          "omp for simd loop exprs were not built");
5563 
5564   if (!CurContext->isDependentContext()) {
5565     // Finalize the clauses that need pre-built expressions for CodeGen.
5566     for (auto C : Clauses) {
5567       if (auto LC = dyn_cast<OMPLinearClause>(C))
5568         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5569                                      B.NumIterations, *this, CurScope,
5570                                      DSAStack))
5571           return StmtError();
5572     }
5573   }
5574 
5575   // OpenMP 4.1 [2.8.1, simd Construct, Restrictions]
5576   // If both simdlen and safelen clauses are specified, the value of the simdlen
5577   // parameter must be less than or equal to the value of the safelen parameter.
5578   OMPSafelenClause *Safelen = nullptr;
5579   OMPSimdlenClause *Simdlen = nullptr;
5580   for (auto *Clause : Clauses) {
5581     if (Clause->getClauseKind() == OMPC_safelen)
5582       Safelen = cast<OMPSafelenClause>(Clause);
5583     else if (Clause->getClauseKind() == OMPC_simdlen)
5584       Simdlen = cast<OMPSimdlenClause>(Clause);
5585     if (Safelen && Simdlen)
5586       break;
5587   }
5588   if (Simdlen && Safelen &&
5589       checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(),
5590                                 Safelen->getSafelen()))
5591     return StmtError();
5592 
5593   getCurFunction()->setHasBranchProtectedScope();
5594   return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
5595                                      Clauses, AStmt, B);
5596 }
5597 
ActOnOpenMPSectionsDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5598 StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
5599                                               Stmt *AStmt,
5600                                               SourceLocation StartLoc,
5601                                               SourceLocation EndLoc) {
5602   if (!AStmt)
5603     return StmtError();
5604 
5605   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5606   auto BaseStmt = AStmt;
5607   while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
5608     BaseStmt = CS->getCapturedStmt();
5609   if (auto C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
5610     auto S = C->children();
5611     if (S.begin() == S.end())
5612       return StmtError();
5613     // All associated statements must be '#pragma omp section' except for
5614     // the first one.
5615     for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
5616       if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
5617         if (SectionStmt)
5618           Diag(SectionStmt->getLocStart(),
5619                diag::err_omp_sections_substmt_not_section);
5620         return StmtError();
5621       }
5622       cast<OMPSectionDirective>(SectionStmt)
5623           ->setHasCancel(DSAStack->isCancelRegion());
5624     }
5625   } else {
5626     Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt);
5627     return StmtError();
5628   }
5629 
5630   getCurFunction()->setHasBranchProtectedScope();
5631 
5632   return OMPSectionsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5633                                       DSAStack->isCancelRegion());
5634 }
5635 
ActOnOpenMPSectionDirective(Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5636 StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
5637                                              SourceLocation StartLoc,
5638                                              SourceLocation EndLoc) {
5639   if (!AStmt)
5640     return StmtError();
5641 
5642   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5643 
5644   getCurFunction()->setHasBranchProtectedScope();
5645   DSAStack->setParentCancelRegion(DSAStack->isCancelRegion());
5646 
5647   return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt,
5648                                      DSAStack->isCancelRegion());
5649 }
5650 
ActOnOpenMPSingleDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5651 StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
5652                                             Stmt *AStmt,
5653                                             SourceLocation StartLoc,
5654                                             SourceLocation EndLoc) {
5655   if (!AStmt)
5656     return StmtError();
5657 
5658   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5659 
5660   getCurFunction()->setHasBranchProtectedScope();
5661 
5662   // OpenMP [2.7.3, single Construct, Restrictions]
5663   // The copyprivate clause must not be used with the nowait clause.
5664   OMPClause *Nowait = nullptr;
5665   OMPClause *Copyprivate = nullptr;
5666   for (auto *Clause : Clauses) {
5667     if (Clause->getClauseKind() == OMPC_nowait)
5668       Nowait = Clause;
5669     else if (Clause->getClauseKind() == OMPC_copyprivate)
5670       Copyprivate = Clause;
5671     if (Copyprivate && Nowait) {
5672       Diag(Copyprivate->getLocStart(),
5673            diag::err_omp_single_copyprivate_with_nowait);
5674       Diag(Nowait->getLocStart(), diag::note_omp_nowait_clause_here);
5675       return StmtError();
5676     }
5677   }
5678 
5679   return OMPSingleDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5680 }
5681 
ActOnOpenMPMasterDirective(Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5682 StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
5683                                             SourceLocation StartLoc,
5684                                             SourceLocation EndLoc) {
5685   if (!AStmt)
5686     return StmtError();
5687 
5688   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5689 
5690   getCurFunction()->setHasBranchProtectedScope();
5691 
5692   return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt);
5693 }
5694 
ActOnOpenMPCriticalDirective(const DeclarationNameInfo & DirName,ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5695 StmtResult Sema::ActOnOpenMPCriticalDirective(
5696     const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses,
5697     Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
5698   if (!AStmt)
5699     return StmtError();
5700 
5701   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5702 
5703   bool ErrorFound = false;
5704   llvm::APSInt Hint;
5705   SourceLocation HintLoc;
5706   bool DependentHint = false;
5707   for (auto *C : Clauses) {
5708     if (C->getClauseKind() == OMPC_hint) {
5709       if (!DirName.getName()) {
5710         Diag(C->getLocStart(), diag::err_omp_hint_clause_no_name);
5711         ErrorFound = true;
5712       }
5713       Expr *E = cast<OMPHintClause>(C)->getHint();
5714       if (E->isTypeDependent() || E->isValueDependent() ||
5715           E->isInstantiationDependent())
5716         DependentHint = true;
5717       else {
5718         Hint = E->EvaluateKnownConstInt(Context);
5719         HintLoc = C->getLocStart();
5720       }
5721     }
5722   }
5723   if (ErrorFound)
5724     return StmtError();
5725   auto Pair = DSAStack->getCriticalWithHint(DirName);
5726   if (Pair.first && DirName.getName() && !DependentHint) {
5727     if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {
5728       Diag(StartLoc, diag::err_omp_critical_with_hint);
5729       if (HintLoc.isValid()) {
5730         Diag(HintLoc, diag::note_omp_critical_hint_here)
5731             << 0 << Hint.toString(/*Radix=*/10, /*Signed=*/false);
5732       } else
5733         Diag(StartLoc, diag::note_omp_critical_no_hint) << 0;
5734       if (auto *C = Pair.first->getSingleClause<OMPHintClause>()) {
5735         Diag(C->getLocStart(), diag::note_omp_critical_hint_here)
5736             << 1
5737             << C->getHint()->EvaluateKnownConstInt(Context).toString(
5738                    /*Radix=*/10, /*Signed=*/false);
5739       } else
5740         Diag(Pair.first->getLocStart(), diag::note_omp_critical_no_hint) << 1;
5741     }
5742   }
5743 
5744   getCurFunction()->setHasBranchProtectedScope();
5745 
5746   auto *Dir = OMPCriticalDirective::Create(Context, DirName, StartLoc, EndLoc,
5747                                            Clauses, AStmt);
5748   if (!Pair.first && DirName.getName() && !DependentHint)
5749     DSAStack->addCriticalWithHint(Dir, Hint);
5750   return Dir;
5751 }
5752 
ActOnOpenMPParallelForDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)5753 StmtResult Sema::ActOnOpenMPParallelForDirective(
5754     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5755     SourceLocation EndLoc,
5756     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5757   if (!AStmt)
5758     return StmtError();
5759 
5760   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5761   // 1.2.2 OpenMP Language Terminology
5762   // Structured block - An executable statement with a single entry at the
5763   // top and a single exit at the bottom.
5764   // The point of exit cannot be a branch out of the structured block.
5765   // longjmp() and throw() must not violate the entry/exit criteria.
5766   CS->getCapturedDecl()->setNothrow();
5767 
5768   OMPLoopDirective::HelperExprs B;
5769   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5770   // define the nested loops number.
5771   unsigned NestedLoopCount =
5772       CheckOpenMPLoop(OMPD_parallel_for, getCollapseNumberExpr(Clauses),
5773                       getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5774                       VarsWithImplicitDSA, B);
5775   if (NestedLoopCount == 0)
5776     return StmtError();
5777 
5778   assert((CurContext->isDependentContext() || B.builtAll()) &&
5779          "omp parallel for loop exprs were not built");
5780 
5781   if (!CurContext->isDependentContext()) {
5782     // Finalize the clauses that need pre-built expressions for CodeGen.
5783     for (auto C : Clauses) {
5784       if (auto LC = dyn_cast<OMPLinearClause>(C))
5785         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5786                                      B.NumIterations, *this, CurScope,
5787                                      DSAStack))
5788           return StmtError();
5789     }
5790   }
5791 
5792   getCurFunction()->setHasBranchProtectedScope();
5793   return OMPParallelForDirective::Create(Context, StartLoc, EndLoc,
5794                                          NestedLoopCount, Clauses, AStmt, B,
5795                                          DSAStack->isCancelRegion());
5796 }
5797 
ActOnOpenMPParallelForSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)5798 StmtResult Sema::ActOnOpenMPParallelForSimdDirective(
5799     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5800     SourceLocation EndLoc,
5801     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5802   if (!AStmt)
5803     return StmtError();
5804 
5805   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5806   // 1.2.2 OpenMP Language Terminology
5807   // Structured block - An executable statement with a single entry at the
5808   // top and a single exit at the bottom.
5809   // The point of exit cannot be a branch out of the structured block.
5810   // longjmp() and throw() must not violate the entry/exit criteria.
5811   CS->getCapturedDecl()->setNothrow();
5812 
5813   OMPLoopDirective::HelperExprs B;
5814   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5815   // define the nested loops number.
5816   unsigned NestedLoopCount =
5817       CheckOpenMPLoop(OMPD_parallel_for_simd, getCollapseNumberExpr(Clauses),
5818                       getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5819                       VarsWithImplicitDSA, B);
5820   if (NestedLoopCount == 0)
5821     return StmtError();
5822 
5823   if (!CurContext->isDependentContext()) {
5824     // Finalize the clauses that need pre-built expressions for CodeGen.
5825     for (auto C : Clauses) {
5826       if (auto LC = dyn_cast<OMPLinearClause>(C))
5827         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5828                                      B.NumIterations, *this, CurScope,
5829                                      DSAStack))
5830           return StmtError();
5831     }
5832   }
5833 
5834   // OpenMP 4.1 [2.8.1, simd Construct, Restrictions]
5835   // If both simdlen and safelen clauses are specified, the value of the simdlen
5836   // parameter must be less than or equal to the value of the safelen parameter.
5837   OMPSafelenClause *Safelen = nullptr;
5838   OMPSimdlenClause *Simdlen = nullptr;
5839   for (auto *Clause : Clauses) {
5840     if (Clause->getClauseKind() == OMPC_safelen)
5841       Safelen = cast<OMPSafelenClause>(Clause);
5842     else if (Clause->getClauseKind() == OMPC_simdlen)
5843       Simdlen = cast<OMPSimdlenClause>(Clause);
5844     if (Safelen && Simdlen)
5845       break;
5846   }
5847   if (Simdlen && Safelen &&
5848       checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(),
5849                                 Safelen->getSafelen()))
5850     return StmtError();
5851 
5852   getCurFunction()->setHasBranchProtectedScope();
5853   return OMPParallelForSimdDirective::Create(
5854       Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
5855 }
5856 
5857 StmtResult
ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5858 Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
5859                                            Stmt *AStmt, SourceLocation StartLoc,
5860                                            SourceLocation EndLoc) {
5861   if (!AStmt)
5862     return StmtError();
5863 
5864   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5865   auto BaseStmt = AStmt;
5866   while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
5867     BaseStmt = CS->getCapturedStmt();
5868   if (auto C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
5869     auto S = C->children();
5870     if (S.begin() == S.end())
5871       return StmtError();
5872     // All associated statements must be '#pragma omp section' except for
5873     // the first one.
5874     for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
5875       if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
5876         if (SectionStmt)
5877           Diag(SectionStmt->getLocStart(),
5878                diag::err_omp_parallel_sections_substmt_not_section);
5879         return StmtError();
5880       }
5881       cast<OMPSectionDirective>(SectionStmt)
5882           ->setHasCancel(DSAStack->isCancelRegion());
5883     }
5884   } else {
5885     Diag(AStmt->getLocStart(),
5886          diag::err_omp_parallel_sections_not_compound_stmt);
5887     return StmtError();
5888   }
5889 
5890   getCurFunction()->setHasBranchProtectedScope();
5891 
5892   return OMPParallelSectionsDirective::Create(
5893       Context, StartLoc, EndLoc, Clauses, AStmt, DSAStack->isCancelRegion());
5894 }
5895 
ActOnOpenMPTaskDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5896 StmtResult Sema::ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
5897                                           Stmt *AStmt, SourceLocation StartLoc,
5898                                           SourceLocation EndLoc) {
5899   if (!AStmt)
5900     return StmtError();
5901 
5902   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5903   // 1.2.2 OpenMP Language Terminology
5904   // Structured block - An executable statement with a single entry at the
5905   // top and a single exit at the bottom.
5906   // The point of exit cannot be a branch out of the structured block.
5907   // longjmp() and throw() must not violate the entry/exit criteria.
5908   CS->getCapturedDecl()->setNothrow();
5909 
5910   getCurFunction()->setHasBranchProtectedScope();
5911 
5912   return OMPTaskDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5913                                   DSAStack->isCancelRegion());
5914 }
5915 
ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,SourceLocation EndLoc)5916 StmtResult Sema::ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
5917                                                SourceLocation EndLoc) {
5918   return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc);
5919 }
5920 
ActOnOpenMPBarrierDirective(SourceLocation StartLoc,SourceLocation EndLoc)5921 StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
5922                                              SourceLocation EndLoc) {
5923   return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
5924 }
5925 
ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,SourceLocation EndLoc)5926 StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
5927                                               SourceLocation EndLoc) {
5928   return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc);
5929 }
5930 
ActOnOpenMPTaskgroupDirective(Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5931 StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt,
5932                                                SourceLocation StartLoc,
5933                                                SourceLocation EndLoc) {
5934   if (!AStmt)
5935     return StmtError();
5936 
5937   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5938 
5939   getCurFunction()->setHasBranchProtectedScope();
5940 
5941   return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt);
5942 }
5943 
ActOnOpenMPFlushDirective(ArrayRef<OMPClause * > Clauses,SourceLocation StartLoc,SourceLocation EndLoc)5944 StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
5945                                            SourceLocation StartLoc,
5946                                            SourceLocation EndLoc) {
5947   assert(Clauses.size() <= 1 && "Extra clauses in flush directive");
5948   return OMPFlushDirective::Create(Context, StartLoc, EndLoc, Clauses);
5949 }
5950 
ActOnOpenMPOrderedDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)5951 StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
5952                                              Stmt *AStmt,
5953                                              SourceLocation StartLoc,
5954                                              SourceLocation EndLoc) {
5955   OMPClause *DependFound = nullptr;
5956   OMPClause *DependSourceClause = nullptr;
5957   OMPClause *DependSinkClause = nullptr;
5958   bool ErrorFound = false;
5959   OMPThreadsClause *TC = nullptr;
5960   OMPSIMDClause *SC = nullptr;
5961   for (auto *C : Clauses) {
5962     if (auto *DC = dyn_cast<OMPDependClause>(C)) {
5963       DependFound = C;
5964       if (DC->getDependencyKind() == OMPC_DEPEND_source) {
5965         if (DependSourceClause) {
5966           Diag(C->getLocStart(), diag::err_omp_more_one_clause)
5967               << getOpenMPDirectiveName(OMPD_ordered)
5968               << getOpenMPClauseName(OMPC_depend) << 2;
5969           ErrorFound = true;
5970         } else
5971           DependSourceClause = C;
5972         if (DependSinkClause) {
5973           Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
5974               << 0;
5975           ErrorFound = true;
5976         }
5977       } else if (DC->getDependencyKind() == OMPC_DEPEND_sink) {
5978         if (DependSourceClause) {
5979           Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
5980               << 1;
5981           ErrorFound = true;
5982         }
5983         DependSinkClause = C;
5984       }
5985     } else if (C->getClauseKind() == OMPC_threads)
5986       TC = cast<OMPThreadsClause>(C);
5987     else if (C->getClauseKind() == OMPC_simd)
5988       SC = cast<OMPSIMDClause>(C);
5989   }
5990   if (!ErrorFound && !SC &&
5991       isOpenMPSimdDirective(DSAStack->getParentDirective())) {
5992     // OpenMP [2.8.1,simd Construct, Restrictions]
5993     // An ordered construct with the simd clause is the only OpenMP construct
5994     // that can appear in the simd region.
5995     Diag(StartLoc, diag::err_omp_prohibited_region_simd);
5996     ErrorFound = true;
5997   } else if (DependFound && (TC || SC)) {
5998     Diag(DependFound->getLocStart(), diag::err_omp_depend_clause_thread_simd)
5999         << getOpenMPClauseName(TC ? TC->getClauseKind() : SC->getClauseKind());
6000     ErrorFound = true;
6001   } else if (DependFound && !DSAStack->getParentOrderedRegionParam()) {
6002     Diag(DependFound->getLocStart(),
6003          diag::err_omp_ordered_directive_without_param);
6004     ErrorFound = true;
6005   } else if (TC || Clauses.empty()) {
6006     if (auto *Param = DSAStack->getParentOrderedRegionParam()) {
6007       SourceLocation ErrLoc = TC ? TC->getLocStart() : StartLoc;
6008       Diag(ErrLoc, diag::err_omp_ordered_directive_with_param)
6009           << (TC != nullptr);
6010       Diag(Param->getLocStart(), diag::note_omp_ordered_param);
6011       ErrorFound = true;
6012     }
6013   }
6014   if ((!AStmt && !DependFound) || ErrorFound)
6015     return StmtError();
6016 
6017   if (AStmt) {
6018     assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6019 
6020     getCurFunction()->setHasBranchProtectedScope();
6021   }
6022 
6023   return OMPOrderedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6024 }
6025 
6026 namespace {
6027 /// \brief Helper class for checking expression in 'omp atomic [update]'
6028 /// construct.
6029 class OpenMPAtomicUpdateChecker {
6030   /// \brief Error results for atomic update expressions.
6031   enum ExprAnalysisErrorCode {
6032     /// \brief A statement is not an expression statement.
6033     NotAnExpression,
6034     /// \brief Expression is not builtin binary or unary operation.
6035     NotABinaryOrUnaryExpression,
6036     /// \brief Unary operation is not post-/pre- increment/decrement operation.
6037     NotAnUnaryIncDecExpression,
6038     /// \brief An expression is not of scalar type.
6039     NotAScalarType,
6040     /// \brief A binary operation is not an assignment operation.
6041     NotAnAssignmentOp,
6042     /// \brief RHS part of the binary operation is not a binary expression.
6043     NotABinaryExpression,
6044     /// \brief RHS part is not additive/multiplicative/shift/biwise binary
6045     /// expression.
6046     NotABinaryOperator,
6047     /// \brief RHS binary operation does not have reference to the updated LHS
6048     /// part.
6049     NotAnUpdateExpression,
6050     /// \brief No errors is found.
6051     NoError
6052   };
6053   /// \brief Reference to Sema.
6054   Sema &SemaRef;
6055   /// \brief A location for note diagnostics (when error is found).
6056   SourceLocation NoteLoc;
6057   /// \brief 'x' lvalue part of the source atomic expression.
6058   Expr *X;
6059   /// \brief 'expr' rvalue part of the source atomic expression.
6060   Expr *E;
6061   /// \brief Helper expression of the form
6062   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
6063   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
6064   Expr *UpdateExpr;
6065   /// \brief Is 'x' a LHS in a RHS part of full update expression. It is
6066   /// important for non-associative operations.
6067   bool IsXLHSInRHSPart;
6068   BinaryOperatorKind Op;
6069   SourceLocation OpLoc;
6070   /// \brief true if the source expression is a postfix unary operation, false
6071   /// if it is a prefix unary operation.
6072   bool IsPostfixUpdate;
6073 
6074 public:
OpenMPAtomicUpdateChecker(Sema & SemaRef)6075   OpenMPAtomicUpdateChecker(Sema &SemaRef)
6076       : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr),
6077         IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {}
6078   /// \brief Check specified statement that it is suitable for 'atomic update'
6079   /// constructs and extract 'x', 'expr' and Operation from the original
6080   /// expression. If DiagId and NoteId == 0, then only check is performed
6081   /// without error notification.
6082   /// \param DiagId Diagnostic which should be emitted if error is found.
6083   /// \param NoteId Diagnostic note for the main error message.
6084   /// \return true if statement is not an update expression, false otherwise.
6085   bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0);
6086   /// \brief Return the 'x' lvalue part of the source atomic expression.
getX() const6087   Expr *getX() const { return X; }
6088   /// \brief Return the 'expr' rvalue part of the source atomic expression.
getExpr() const6089   Expr *getExpr() const { return E; }
6090   /// \brief Return the update expression used in calculation of the updated
6091   /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
6092   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
getUpdateExpr() const6093   Expr *getUpdateExpr() const { return UpdateExpr; }
6094   /// \brief Return true if 'x' is LHS in RHS part of full update expression,
6095   /// false otherwise.
isXLHSInRHSPart() const6096   bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
6097 
6098   /// \brief true if the source expression is a postfix unary operation, false
6099   /// if it is a prefix unary operation.
isPostfixUpdate() const6100   bool isPostfixUpdate() const { return IsPostfixUpdate; }
6101 
6102 private:
6103   bool checkBinaryOperation(BinaryOperator *AtomicBinOp, unsigned DiagId = 0,
6104                             unsigned NoteId = 0);
6105 };
6106 } // namespace
6107 
checkBinaryOperation(BinaryOperator * AtomicBinOp,unsigned DiagId,unsigned NoteId)6108 bool OpenMPAtomicUpdateChecker::checkBinaryOperation(
6109     BinaryOperator *AtomicBinOp, unsigned DiagId, unsigned NoteId) {
6110   ExprAnalysisErrorCode ErrorFound = NoError;
6111   SourceLocation ErrorLoc, NoteLoc;
6112   SourceRange ErrorRange, NoteRange;
6113   // Allowed constructs are:
6114   //  x = x binop expr;
6115   //  x = expr binop x;
6116   if (AtomicBinOp->getOpcode() == BO_Assign) {
6117     X = AtomicBinOp->getLHS();
6118     if (auto *AtomicInnerBinOp = dyn_cast<BinaryOperator>(
6119             AtomicBinOp->getRHS()->IgnoreParenImpCasts())) {
6120       if (AtomicInnerBinOp->isMultiplicativeOp() ||
6121           AtomicInnerBinOp->isAdditiveOp() || AtomicInnerBinOp->isShiftOp() ||
6122           AtomicInnerBinOp->isBitwiseOp()) {
6123         Op = AtomicInnerBinOp->getOpcode();
6124         OpLoc = AtomicInnerBinOp->getOperatorLoc();
6125         auto *LHS = AtomicInnerBinOp->getLHS();
6126         auto *RHS = AtomicInnerBinOp->getRHS();
6127         llvm::FoldingSetNodeID XId, LHSId, RHSId;
6128         X->IgnoreParenImpCasts()->Profile(XId, SemaRef.getASTContext(),
6129                                           /*Canonical=*/true);
6130         LHS->IgnoreParenImpCasts()->Profile(LHSId, SemaRef.getASTContext(),
6131                                             /*Canonical=*/true);
6132         RHS->IgnoreParenImpCasts()->Profile(RHSId, SemaRef.getASTContext(),
6133                                             /*Canonical=*/true);
6134         if (XId == LHSId) {
6135           E = RHS;
6136           IsXLHSInRHSPart = true;
6137         } else if (XId == RHSId) {
6138           E = LHS;
6139           IsXLHSInRHSPart = false;
6140         } else {
6141           ErrorLoc = AtomicInnerBinOp->getExprLoc();
6142           ErrorRange = AtomicInnerBinOp->getSourceRange();
6143           NoteLoc = X->getExprLoc();
6144           NoteRange = X->getSourceRange();
6145           ErrorFound = NotAnUpdateExpression;
6146         }
6147       } else {
6148         ErrorLoc = AtomicInnerBinOp->getExprLoc();
6149         ErrorRange = AtomicInnerBinOp->getSourceRange();
6150         NoteLoc = AtomicInnerBinOp->getOperatorLoc();
6151         NoteRange = SourceRange(NoteLoc, NoteLoc);
6152         ErrorFound = NotABinaryOperator;
6153       }
6154     } else {
6155       NoteLoc = ErrorLoc = AtomicBinOp->getRHS()->getExprLoc();
6156       NoteRange = ErrorRange = AtomicBinOp->getRHS()->getSourceRange();
6157       ErrorFound = NotABinaryExpression;
6158     }
6159   } else {
6160     ErrorLoc = AtomicBinOp->getExprLoc();
6161     ErrorRange = AtomicBinOp->getSourceRange();
6162     NoteLoc = AtomicBinOp->getOperatorLoc();
6163     NoteRange = SourceRange(NoteLoc, NoteLoc);
6164     ErrorFound = NotAnAssignmentOp;
6165   }
6166   if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
6167     SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
6168     SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
6169     return true;
6170   } else if (SemaRef.CurContext->isDependentContext())
6171     E = X = UpdateExpr = nullptr;
6172   return ErrorFound != NoError;
6173 }
6174 
checkStatement(Stmt * S,unsigned DiagId,unsigned NoteId)6175 bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
6176                                                unsigned NoteId) {
6177   ExprAnalysisErrorCode ErrorFound = NoError;
6178   SourceLocation ErrorLoc, NoteLoc;
6179   SourceRange ErrorRange, NoteRange;
6180   // Allowed constructs are:
6181   //  x++;
6182   //  x--;
6183   //  ++x;
6184   //  --x;
6185   //  x binop= expr;
6186   //  x = x binop expr;
6187   //  x = expr binop x;
6188   if (auto *AtomicBody = dyn_cast<Expr>(S)) {
6189     AtomicBody = AtomicBody->IgnoreParenImpCasts();
6190     if (AtomicBody->getType()->isScalarType() ||
6191         AtomicBody->isInstantiationDependent()) {
6192       if (auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>(
6193               AtomicBody->IgnoreParenImpCasts())) {
6194         // Check for Compound Assignment Operation
6195         Op = BinaryOperator::getOpForCompoundAssignment(
6196             AtomicCompAssignOp->getOpcode());
6197         OpLoc = AtomicCompAssignOp->getOperatorLoc();
6198         E = AtomicCompAssignOp->getRHS();
6199         X = AtomicCompAssignOp->getLHS();
6200         IsXLHSInRHSPart = true;
6201       } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>(
6202                      AtomicBody->IgnoreParenImpCasts())) {
6203         // Check for Binary Operation
6204         if(checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
6205           return true;
6206       } else if (auto *AtomicUnaryOp =
6207                  dyn_cast<UnaryOperator>(AtomicBody->IgnoreParenImpCasts())) {
6208         // Check for Unary Operation
6209         if (AtomicUnaryOp->isIncrementDecrementOp()) {
6210           IsPostfixUpdate = AtomicUnaryOp->isPostfix();
6211           Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub;
6212           OpLoc = AtomicUnaryOp->getOperatorLoc();
6213           X = AtomicUnaryOp->getSubExpr();
6214           E = SemaRef.ActOnIntegerConstant(OpLoc, /*uint64_t Val=*/1).get();
6215           IsXLHSInRHSPart = true;
6216         } else {
6217           ErrorFound = NotAnUnaryIncDecExpression;
6218           ErrorLoc = AtomicUnaryOp->getExprLoc();
6219           ErrorRange = AtomicUnaryOp->getSourceRange();
6220           NoteLoc = AtomicUnaryOp->getOperatorLoc();
6221           NoteRange = SourceRange(NoteLoc, NoteLoc);
6222         }
6223       } else if (!AtomicBody->isInstantiationDependent()) {
6224         ErrorFound = NotABinaryOrUnaryExpression;
6225         NoteLoc = ErrorLoc = AtomicBody->getExprLoc();
6226         NoteRange = ErrorRange = AtomicBody->getSourceRange();
6227       }
6228     } else {
6229       ErrorFound = NotAScalarType;
6230       NoteLoc = ErrorLoc = AtomicBody->getLocStart();
6231       NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6232     }
6233   } else {
6234     ErrorFound = NotAnExpression;
6235     NoteLoc = ErrorLoc = S->getLocStart();
6236     NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6237   }
6238   if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
6239     SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
6240     SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
6241     return true;
6242   } else if (SemaRef.CurContext->isDependentContext())
6243     E = X = UpdateExpr = nullptr;
6244   if (ErrorFound == NoError && E && X) {
6245     // Build an update expression of form 'OpaqueValueExpr(x) binop
6246     // OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop
6247     // OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression.
6248     auto *OVEX = new (SemaRef.getASTContext())
6249         OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue);
6250     auto *OVEExpr = new (SemaRef.getASTContext())
6251         OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue);
6252     auto Update =
6253         SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr,
6254                                    IsXLHSInRHSPart ? OVEExpr : OVEX);
6255     if (Update.isInvalid())
6256       return true;
6257     Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(),
6258                                                Sema::AA_Casting);
6259     if (Update.isInvalid())
6260       return true;
6261     UpdateExpr = Update.get();
6262   }
6263   return ErrorFound != NoError;
6264 }
6265 
ActOnOpenMPAtomicDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)6266 StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
6267                                             Stmt *AStmt,
6268                                             SourceLocation StartLoc,
6269                                             SourceLocation EndLoc) {
6270   if (!AStmt)
6271     return StmtError();
6272 
6273   auto CS = cast<CapturedStmt>(AStmt);
6274   // 1.2.2 OpenMP Language Terminology
6275   // Structured block - An executable statement with a single entry at the
6276   // top and a single exit at the bottom.
6277   // The point of exit cannot be a branch out of the structured block.
6278   // longjmp() and throw() must not violate the entry/exit criteria.
6279   OpenMPClauseKind AtomicKind = OMPC_unknown;
6280   SourceLocation AtomicKindLoc;
6281   for (auto *C : Clauses) {
6282     if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write ||
6283         C->getClauseKind() == OMPC_update ||
6284         C->getClauseKind() == OMPC_capture) {
6285       if (AtomicKind != OMPC_unknown) {
6286         Diag(C->getLocStart(), diag::err_omp_atomic_several_clauses)
6287             << SourceRange(C->getLocStart(), C->getLocEnd());
6288         Diag(AtomicKindLoc, diag::note_omp_atomic_previous_clause)
6289             << getOpenMPClauseName(AtomicKind);
6290       } else {
6291         AtomicKind = C->getClauseKind();
6292         AtomicKindLoc = C->getLocStart();
6293       }
6294     }
6295   }
6296 
6297   auto Body = CS->getCapturedStmt();
6298   if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
6299     Body = EWC->getSubExpr();
6300 
6301   Expr *X = nullptr;
6302   Expr *V = nullptr;
6303   Expr *E = nullptr;
6304   Expr *UE = nullptr;
6305   bool IsXLHSInRHSPart = false;
6306   bool IsPostfixUpdate = false;
6307   // OpenMP [2.12.6, atomic Construct]
6308   // In the next expressions:
6309   // * x and v (as applicable) are both l-value expressions with scalar type.
6310   // * During the execution of an atomic region, multiple syntactic
6311   // occurrences of x must designate the same storage location.
6312   // * Neither of v and expr (as applicable) may access the storage location
6313   // designated by x.
6314   // * Neither of x and expr (as applicable) may access the storage location
6315   // designated by v.
6316   // * expr is an expression with scalar type.
6317   // * binop is one of +, *, -, /, &, ^, |, <<, or >>.
6318   // * binop, binop=, ++, and -- are not overloaded operators.
6319   // * The expression x binop expr must be numerically equivalent to x binop
6320   // (expr). This requirement is satisfied if the operators in expr have
6321   // precedence greater than binop, or by using parentheses around expr or
6322   // subexpressions of expr.
6323   // * The expression expr binop x must be numerically equivalent to (expr)
6324   // binop x. This requirement is satisfied if the operators in expr have
6325   // precedence equal to or greater than binop, or by using parentheses around
6326   // expr or subexpressions of expr.
6327   // * For forms that allow multiple occurrences of x, the number of times
6328   // that x is evaluated is unspecified.
6329   if (AtomicKind == OMPC_read) {
6330     enum {
6331       NotAnExpression,
6332       NotAnAssignmentOp,
6333       NotAScalarType,
6334       NotAnLValue,
6335       NoError
6336     } ErrorFound = NoError;
6337     SourceLocation ErrorLoc, NoteLoc;
6338     SourceRange ErrorRange, NoteRange;
6339     // If clause is read:
6340     //  v = x;
6341     if (auto AtomicBody = dyn_cast<Expr>(Body)) {
6342       auto AtomicBinOp =
6343           dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
6344       if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
6345         X = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
6346         V = AtomicBinOp->getLHS()->IgnoreParenImpCasts();
6347         if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
6348             (V->isInstantiationDependent() || V->getType()->isScalarType())) {
6349           if (!X->isLValue() || !V->isLValue()) {
6350             auto NotLValueExpr = X->isLValue() ? V : X;
6351             ErrorFound = NotAnLValue;
6352             ErrorLoc = AtomicBinOp->getExprLoc();
6353             ErrorRange = AtomicBinOp->getSourceRange();
6354             NoteLoc = NotLValueExpr->getExprLoc();
6355             NoteRange = NotLValueExpr->getSourceRange();
6356           }
6357         } else if (!X->isInstantiationDependent() ||
6358                    !V->isInstantiationDependent()) {
6359           auto NotScalarExpr =
6360               (X->isInstantiationDependent() || X->getType()->isScalarType())
6361                   ? V
6362                   : X;
6363           ErrorFound = NotAScalarType;
6364           ErrorLoc = AtomicBinOp->getExprLoc();
6365           ErrorRange = AtomicBinOp->getSourceRange();
6366           NoteLoc = NotScalarExpr->getExprLoc();
6367           NoteRange = NotScalarExpr->getSourceRange();
6368         }
6369       } else if (!AtomicBody->isInstantiationDependent()) {
6370         ErrorFound = NotAnAssignmentOp;
6371         ErrorLoc = AtomicBody->getExprLoc();
6372         ErrorRange = AtomicBody->getSourceRange();
6373         NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
6374                               : AtomicBody->getExprLoc();
6375         NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
6376                                 : AtomicBody->getSourceRange();
6377       }
6378     } else {
6379       ErrorFound = NotAnExpression;
6380       NoteLoc = ErrorLoc = Body->getLocStart();
6381       NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6382     }
6383     if (ErrorFound != NoError) {
6384       Diag(ErrorLoc, diag::err_omp_atomic_read_not_expression_statement)
6385           << ErrorRange;
6386       Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
6387                                                       << NoteRange;
6388       return StmtError();
6389     } else if (CurContext->isDependentContext())
6390       V = X = nullptr;
6391   } else if (AtomicKind == OMPC_write) {
6392     enum {
6393       NotAnExpression,
6394       NotAnAssignmentOp,
6395       NotAScalarType,
6396       NotAnLValue,
6397       NoError
6398     } ErrorFound = NoError;
6399     SourceLocation ErrorLoc, NoteLoc;
6400     SourceRange ErrorRange, NoteRange;
6401     // If clause is write:
6402     //  x = expr;
6403     if (auto AtomicBody = dyn_cast<Expr>(Body)) {
6404       auto AtomicBinOp =
6405           dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
6406       if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
6407         X = AtomicBinOp->getLHS();
6408         E = AtomicBinOp->getRHS();
6409         if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
6410             (E->isInstantiationDependent() || E->getType()->isScalarType())) {
6411           if (!X->isLValue()) {
6412             ErrorFound = NotAnLValue;
6413             ErrorLoc = AtomicBinOp->getExprLoc();
6414             ErrorRange = AtomicBinOp->getSourceRange();
6415             NoteLoc = X->getExprLoc();
6416             NoteRange = X->getSourceRange();
6417           }
6418         } else if (!X->isInstantiationDependent() ||
6419                    !E->isInstantiationDependent()) {
6420           auto NotScalarExpr =
6421               (X->isInstantiationDependent() || X->getType()->isScalarType())
6422                   ? E
6423                   : X;
6424           ErrorFound = NotAScalarType;
6425           ErrorLoc = AtomicBinOp->getExprLoc();
6426           ErrorRange = AtomicBinOp->getSourceRange();
6427           NoteLoc = NotScalarExpr->getExprLoc();
6428           NoteRange = NotScalarExpr->getSourceRange();
6429         }
6430       } else if (!AtomicBody->isInstantiationDependent()) {
6431         ErrorFound = NotAnAssignmentOp;
6432         ErrorLoc = AtomicBody->getExprLoc();
6433         ErrorRange = AtomicBody->getSourceRange();
6434         NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
6435                               : AtomicBody->getExprLoc();
6436         NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
6437                                 : AtomicBody->getSourceRange();
6438       }
6439     } else {
6440       ErrorFound = NotAnExpression;
6441       NoteLoc = ErrorLoc = Body->getLocStart();
6442       NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6443     }
6444     if (ErrorFound != NoError) {
6445       Diag(ErrorLoc, diag::err_omp_atomic_write_not_expression_statement)
6446           << ErrorRange;
6447       Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
6448                                                       << NoteRange;
6449       return StmtError();
6450     } else if (CurContext->isDependentContext())
6451       E = X = nullptr;
6452   } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {
6453     // If clause is update:
6454     //  x++;
6455     //  x--;
6456     //  ++x;
6457     //  --x;
6458     //  x binop= expr;
6459     //  x = x binop expr;
6460     //  x = expr binop x;
6461     OpenMPAtomicUpdateChecker Checker(*this);
6462     if (Checker.checkStatement(
6463             Body, (AtomicKind == OMPC_update)
6464                       ? diag::err_omp_atomic_update_not_expression_statement
6465                       : diag::err_omp_atomic_not_expression_statement,
6466             diag::note_omp_atomic_update))
6467       return StmtError();
6468     if (!CurContext->isDependentContext()) {
6469       E = Checker.getExpr();
6470       X = Checker.getX();
6471       UE = Checker.getUpdateExpr();
6472       IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6473     }
6474   } else if (AtomicKind == OMPC_capture) {
6475     enum {
6476       NotAnAssignmentOp,
6477       NotACompoundStatement,
6478       NotTwoSubstatements,
6479       NotASpecificExpression,
6480       NoError
6481     } ErrorFound = NoError;
6482     SourceLocation ErrorLoc, NoteLoc;
6483     SourceRange ErrorRange, NoteRange;
6484     if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
6485       // If clause is a capture:
6486       //  v = x++;
6487       //  v = x--;
6488       //  v = ++x;
6489       //  v = --x;
6490       //  v = x binop= expr;
6491       //  v = x = x binop expr;
6492       //  v = x = expr binop x;
6493       auto *AtomicBinOp =
6494           dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
6495       if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
6496         V = AtomicBinOp->getLHS();
6497         Body = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
6498         OpenMPAtomicUpdateChecker Checker(*this);
6499         if (Checker.checkStatement(
6500                 Body, diag::err_omp_atomic_capture_not_expression_statement,
6501                 diag::note_omp_atomic_update))
6502           return StmtError();
6503         E = Checker.getExpr();
6504         X = Checker.getX();
6505         UE = Checker.getUpdateExpr();
6506         IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6507         IsPostfixUpdate = Checker.isPostfixUpdate();
6508       } else if (!AtomicBody->isInstantiationDependent()) {
6509         ErrorLoc = AtomicBody->getExprLoc();
6510         ErrorRange = AtomicBody->getSourceRange();
6511         NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
6512                               : AtomicBody->getExprLoc();
6513         NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
6514                                 : AtomicBody->getSourceRange();
6515         ErrorFound = NotAnAssignmentOp;
6516       }
6517       if (ErrorFound != NoError) {
6518         Diag(ErrorLoc, diag::err_omp_atomic_capture_not_expression_statement)
6519             << ErrorRange;
6520         Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
6521         return StmtError();
6522       } else if (CurContext->isDependentContext()) {
6523         UE = V = E = X = nullptr;
6524       }
6525     } else {
6526       // If clause is a capture:
6527       //  { v = x; x = expr; }
6528       //  { v = x; x++; }
6529       //  { v = x; x--; }
6530       //  { v = x; ++x; }
6531       //  { v = x; --x; }
6532       //  { v = x; x binop= expr; }
6533       //  { v = x; x = x binop expr; }
6534       //  { v = x; x = expr binop x; }
6535       //  { x++; v = x; }
6536       //  { x--; v = x; }
6537       //  { ++x; v = x; }
6538       //  { --x; v = x; }
6539       //  { x binop= expr; v = x; }
6540       //  { x = x binop expr; v = x; }
6541       //  { x = expr binop x; v = x; }
6542       if (auto *CS = dyn_cast<CompoundStmt>(Body)) {
6543         // Check that this is { expr1; expr2; }
6544         if (CS->size() == 2) {
6545           auto *First = CS->body_front();
6546           auto *Second = CS->body_back();
6547           if (auto *EWC = dyn_cast<ExprWithCleanups>(First))
6548             First = EWC->getSubExpr()->IgnoreParenImpCasts();
6549           if (auto *EWC = dyn_cast<ExprWithCleanups>(Second))
6550             Second = EWC->getSubExpr()->IgnoreParenImpCasts();
6551           // Need to find what subexpression is 'v' and what is 'x'.
6552           OpenMPAtomicUpdateChecker Checker(*this);
6553           bool IsUpdateExprFound = !Checker.checkStatement(Second);
6554           BinaryOperator *BinOp = nullptr;
6555           if (IsUpdateExprFound) {
6556             BinOp = dyn_cast<BinaryOperator>(First);
6557             IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
6558           }
6559           if (IsUpdateExprFound && !CurContext->isDependentContext()) {
6560             //  { v = x; x++; }
6561             //  { v = x; x--; }
6562             //  { v = x; ++x; }
6563             //  { v = x; --x; }
6564             //  { v = x; x binop= expr; }
6565             //  { v = x; x = x binop expr; }
6566             //  { v = x; x = expr binop x; }
6567             // Check that the first expression has form v = x.
6568             auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
6569             llvm::FoldingSetNodeID XId, PossibleXId;
6570             Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
6571             PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
6572             IsUpdateExprFound = XId == PossibleXId;
6573             if (IsUpdateExprFound) {
6574               V = BinOp->getLHS();
6575               X = Checker.getX();
6576               E = Checker.getExpr();
6577               UE = Checker.getUpdateExpr();
6578               IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6579               IsPostfixUpdate = true;
6580             }
6581           }
6582           if (!IsUpdateExprFound) {
6583             IsUpdateExprFound = !Checker.checkStatement(First);
6584             BinOp = nullptr;
6585             if (IsUpdateExprFound) {
6586               BinOp = dyn_cast<BinaryOperator>(Second);
6587               IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
6588             }
6589             if (IsUpdateExprFound && !CurContext->isDependentContext()) {
6590               //  { x++; v = x; }
6591               //  { x--; v = x; }
6592               //  { ++x; v = x; }
6593               //  { --x; v = x; }
6594               //  { x binop= expr; v = x; }
6595               //  { x = x binop expr; v = x; }
6596               //  { x = expr binop x; v = x; }
6597               // Check that the second expression has form v = x.
6598               auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
6599               llvm::FoldingSetNodeID XId, PossibleXId;
6600               Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
6601               PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
6602               IsUpdateExprFound = XId == PossibleXId;
6603               if (IsUpdateExprFound) {
6604                 V = BinOp->getLHS();
6605                 X = Checker.getX();
6606                 E = Checker.getExpr();
6607                 UE = Checker.getUpdateExpr();
6608                 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6609                 IsPostfixUpdate = false;
6610               }
6611             }
6612           }
6613           if (!IsUpdateExprFound) {
6614             //  { v = x; x = expr; }
6615             auto *FirstExpr = dyn_cast<Expr>(First);
6616             auto *SecondExpr = dyn_cast<Expr>(Second);
6617             if (!FirstExpr || !SecondExpr ||
6618                 !(FirstExpr->isInstantiationDependent() ||
6619                   SecondExpr->isInstantiationDependent())) {
6620               auto *FirstBinOp = dyn_cast<BinaryOperator>(First);
6621               if (!FirstBinOp || FirstBinOp->getOpcode() != BO_Assign) {
6622                 ErrorFound = NotAnAssignmentOp;
6623                 NoteLoc = ErrorLoc = FirstBinOp ? FirstBinOp->getOperatorLoc()
6624                                                 : First->getLocStart();
6625                 NoteRange = ErrorRange = FirstBinOp
6626                                              ? FirstBinOp->getSourceRange()
6627                                              : SourceRange(ErrorLoc, ErrorLoc);
6628               } else {
6629                 auto *SecondBinOp = dyn_cast<BinaryOperator>(Second);
6630                 if (!SecondBinOp || SecondBinOp->getOpcode() != BO_Assign) {
6631                   ErrorFound = NotAnAssignmentOp;
6632                   NoteLoc = ErrorLoc = SecondBinOp
6633                                            ? SecondBinOp->getOperatorLoc()
6634                                            : Second->getLocStart();
6635                   NoteRange = ErrorRange =
6636                       SecondBinOp ? SecondBinOp->getSourceRange()
6637                                   : SourceRange(ErrorLoc, ErrorLoc);
6638                 } else {
6639                   auto *PossibleXRHSInFirst =
6640                       FirstBinOp->getRHS()->IgnoreParenImpCasts();
6641                   auto *PossibleXLHSInSecond =
6642                       SecondBinOp->getLHS()->IgnoreParenImpCasts();
6643                   llvm::FoldingSetNodeID X1Id, X2Id;
6644                   PossibleXRHSInFirst->Profile(X1Id, Context,
6645                                                /*Canonical=*/true);
6646                   PossibleXLHSInSecond->Profile(X2Id, Context,
6647                                                 /*Canonical=*/true);
6648                   IsUpdateExprFound = X1Id == X2Id;
6649                   if (IsUpdateExprFound) {
6650                     V = FirstBinOp->getLHS();
6651                     X = SecondBinOp->getLHS();
6652                     E = SecondBinOp->getRHS();
6653                     UE = nullptr;
6654                     IsXLHSInRHSPart = false;
6655                     IsPostfixUpdate = true;
6656                   } else {
6657                     ErrorFound = NotASpecificExpression;
6658                     ErrorLoc = FirstBinOp->getExprLoc();
6659                     ErrorRange = FirstBinOp->getSourceRange();
6660                     NoteLoc = SecondBinOp->getLHS()->getExprLoc();
6661                     NoteRange = SecondBinOp->getRHS()->getSourceRange();
6662                   }
6663                 }
6664               }
6665             }
6666           }
6667         } else {
6668           NoteLoc = ErrorLoc = Body->getLocStart();
6669           NoteRange = ErrorRange =
6670               SourceRange(Body->getLocStart(), Body->getLocStart());
6671           ErrorFound = NotTwoSubstatements;
6672         }
6673       } else {
6674         NoteLoc = ErrorLoc = Body->getLocStart();
6675         NoteRange = ErrorRange =
6676             SourceRange(Body->getLocStart(), Body->getLocStart());
6677         ErrorFound = NotACompoundStatement;
6678       }
6679       if (ErrorFound != NoError) {
6680         Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement)
6681             << ErrorRange;
6682         Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
6683         return StmtError();
6684       } else if (CurContext->isDependentContext()) {
6685         UE = V = E = X = nullptr;
6686       }
6687     }
6688   }
6689 
6690   getCurFunction()->setHasBranchProtectedScope();
6691 
6692   return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
6693                                     X, V, E, UE, IsXLHSInRHSPart,
6694                                     IsPostfixUpdate);
6695 }
6696 
ActOnOpenMPTargetDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)6697 StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
6698                                             Stmt *AStmt,
6699                                             SourceLocation StartLoc,
6700                                             SourceLocation EndLoc) {
6701   if (!AStmt)
6702     return StmtError();
6703 
6704   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6705   // 1.2.2 OpenMP Language Terminology
6706   // Structured block - An executable statement with a single entry at the
6707   // top and a single exit at the bottom.
6708   // The point of exit cannot be a branch out of the structured block.
6709   // longjmp() and throw() must not violate the entry/exit criteria.
6710   CS->getCapturedDecl()->setNothrow();
6711 
6712   // OpenMP [2.16, Nesting of Regions]
6713   // If specified, a teams construct must be contained within a target
6714   // construct. That target construct must contain no statements or directives
6715   // outside of the teams construct.
6716   if (DSAStack->hasInnerTeamsRegion()) {
6717     auto S = AStmt->IgnoreContainers(/*IgnoreCaptured*/ true);
6718     bool OMPTeamsFound = true;
6719     if (auto *CS = dyn_cast<CompoundStmt>(S)) {
6720       auto I = CS->body_begin();
6721       while (I != CS->body_end()) {
6722         auto OED = dyn_cast<OMPExecutableDirective>(*I);
6723         if (!OED || !isOpenMPTeamsDirective(OED->getDirectiveKind())) {
6724           OMPTeamsFound = false;
6725           break;
6726         }
6727         ++I;
6728       }
6729       assert(I != CS->body_end() && "Not found statement");
6730       S = *I;
6731     } else {
6732       auto *OED = dyn_cast<OMPExecutableDirective>(S);
6733       OMPTeamsFound = OED && isOpenMPTeamsDirective(OED->getDirectiveKind());
6734     }
6735     if (!OMPTeamsFound) {
6736       Diag(StartLoc, diag::err_omp_target_contains_not_only_teams);
6737       Diag(DSAStack->getInnerTeamsRegionLoc(),
6738            diag::note_omp_nested_teams_construct_here);
6739       Diag(S->getLocStart(), diag::note_omp_nested_statement_here)
6740           << isa<OMPExecutableDirective>(S);
6741       return StmtError();
6742     }
6743   }
6744 
6745   getCurFunction()->setHasBranchProtectedScope();
6746 
6747   return OMPTargetDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6748 }
6749 
6750 StmtResult
ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)6751 Sema::ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
6752                                          Stmt *AStmt, SourceLocation StartLoc,
6753                                          SourceLocation EndLoc) {
6754   if (!AStmt)
6755     return StmtError();
6756 
6757   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6758   // 1.2.2 OpenMP Language Terminology
6759   // Structured block - An executable statement with a single entry at the
6760   // top and a single exit at the bottom.
6761   // The point of exit cannot be a branch out of the structured block.
6762   // longjmp() and throw() must not violate the entry/exit criteria.
6763   CS->getCapturedDecl()->setNothrow();
6764 
6765   getCurFunction()->setHasBranchProtectedScope();
6766 
6767   return OMPTargetParallelDirective::Create(Context, StartLoc, EndLoc, Clauses,
6768                                             AStmt);
6769 }
6770 
ActOnOpenMPTargetParallelForDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)6771 StmtResult Sema::ActOnOpenMPTargetParallelForDirective(
6772     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6773     SourceLocation EndLoc,
6774     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6775   if (!AStmt)
6776     return StmtError();
6777 
6778   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6779   // 1.2.2 OpenMP Language Terminology
6780   // Structured block - An executable statement with a single entry at the
6781   // top and a single exit at the bottom.
6782   // The point of exit cannot be a branch out of the structured block.
6783   // longjmp() and throw() must not violate the entry/exit criteria.
6784   CS->getCapturedDecl()->setNothrow();
6785 
6786   OMPLoopDirective::HelperExprs B;
6787   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6788   // define the nested loops number.
6789   unsigned NestedLoopCount =
6790       CheckOpenMPLoop(OMPD_target_parallel_for, getCollapseNumberExpr(Clauses),
6791                       getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
6792                       VarsWithImplicitDSA, B);
6793   if (NestedLoopCount == 0)
6794     return StmtError();
6795 
6796   assert((CurContext->isDependentContext() || B.builtAll()) &&
6797          "omp target parallel for loop exprs were not built");
6798 
6799   if (!CurContext->isDependentContext()) {
6800     // Finalize the clauses that need pre-built expressions for CodeGen.
6801     for (auto C : Clauses) {
6802       if (auto LC = dyn_cast<OMPLinearClause>(C))
6803         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6804                                      B.NumIterations, *this, CurScope,
6805                                      DSAStack))
6806           return StmtError();
6807     }
6808   }
6809 
6810   getCurFunction()->setHasBranchProtectedScope();
6811   return OMPTargetParallelForDirective::Create(Context, StartLoc, EndLoc,
6812                                                NestedLoopCount, Clauses, AStmt,
6813                                                B, DSAStack->isCancelRegion());
6814 }
6815 
6816 /// \brief Check for existence of a map clause in the list of clauses.
HasMapClause(ArrayRef<OMPClause * > Clauses)6817 static bool HasMapClause(ArrayRef<OMPClause *> Clauses) {
6818   for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
6819        I != E; ++I) {
6820     if (*I != nullptr && (*I)->getClauseKind() == OMPC_map) {
6821       return true;
6822     }
6823   }
6824 
6825   return false;
6826 }
6827 
ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)6828 StmtResult Sema::ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
6829                                                 Stmt *AStmt,
6830                                                 SourceLocation StartLoc,
6831                                                 SourceLocation EndLoc) {
6832   if (!AStmt)
6833     return StmtError();
6834 
6835   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6836 
6837   // OpenMP [2.10.1, Restrictions, p. 97]
6838   // At least one map clause must appear on the directive.
6839   if (!HasMapClause(Clauses)) {
6840     Diag(StartLoc, diag::err_omp_no_map_for_directive) <<
6841         getOpenMPDirectiveName(OMPD_target_data);
6842     return StmtError();
6843   }
6844 
6845   getCurFunction()->setHasBranchProtectedScope();
6846 
6847   return OMPTargetDataDirective::Create(Context, StartLoc, EndLoc, Clauses,
6848                                         AStmt);
6849 }
6850 
6851 StmtResult
ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause * > Clauses,SourceLocation StartLoc,SourceLocation EndLoc)6852 Sema::ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
6853                                           SourceLocation StartLoc,
6854                                           SourceLocation EndLoc) {
6855   // OpenMP [2.10.2, Restrictions, p. 99]
6856   // At least one map clause must appear on the directive.
6857   if (!HasMapClause(Clauses)) {
6858     Diag(StartLoc, diag::err_omp_no_map_for_directive)
6859         << getOpenMPDirectiveName(OMPD_target_enter_data);
6860     return StmtError();
6861   }
6862 
6863   return OMPTargetEnterDataDirective::Create(Context, StartLoc, EndLoc,
6864                                              Clauses);
6865 }
6866 
6867 StmtResult
ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause * > Clauses,SourceLocation StartLoc,SourceLocation EndLoc)6868 Sema::ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
6869                                          SourceLocation StartLoc,
6870                                          SourceLocation EndLoc) {
6871   // OpenMP [2.10.3, Restrictions, p. 102]
6872   // At least one map clause must appear on the directive.
6873   if (!HasMapClause(Clauses)) {
6874     Diag(StartLoc, diag::err_omp_no_map_for_directive)
6875         << getOpenMPDirectiveName(OMPD_target_exit_data);
6876     return StmtError();
6877   }
6878 
6879   return OMPTargetExitDataDirective::Create(Context, StartLoc, EndLoc, Clauses);
6880 }
6881 
ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause * > Clauses,SourceLocation StartLoc,SourceLocation EndLoc)6882 StmtResult Sema::ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
6883                                                   SourceLocation StartLoc,
6884                                                   SourceLocation EndLoc) {
6885   bool seenMotionClause = false;
6886   for (auto *C : Clauses) {
6887     if (C->getClauseKind() == OMPC_to || C->getClauseKind() == OMPC_from)
6888       seenMotionClause = true;
6889   }
6890   if (!seenMotionClause) {
6891     Diag(StartLoc, diag::err_omp_at_least_one_motion_clause_required);
6892     return StmtError();
6893   }
6894   return OMPTargetUpdateDirective::Create(Context, StartLoc, EndLoc, Clauses);
6895 }
6896 
ActOnOpenMPTeamsDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc)6897 StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
6898                                            Stmt *AStmt, SourceLocation StartLoc,
6899                                            SourceLocation EndLoc) {
6900   if (!AStmt)
6901     return StmtError();
6902 
6903   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6904   // 1.2.2 OpenMP Language Terminology
6905   // Structured block - An executable statement with a single entry at the
6906   // top and a single exit at the bottom.
6907   // The point of exit cannot be a branch out of the structured block.
6908   // longjmp() and throw() must not violate the entry/exit criteria.
6909   CS->getCapturedDecl()->setNothrow();
6910 
6911   getCurFunction()->setHasBranchProtectedScope();
6912 
6913   return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6914 }
6915 
6916 StmtResult
ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,SourceLocation EndLoc,OpenMPDirectiveKind CancelRegion)6917 Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
6918                                             SourceLocation EndLoc,
6919                                             OpenMPDirectiveKind CancelRegion) {
6920   if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
6921       CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
6922     Diag(StartLoc, diag::err_omp_wrong_cancel_region)
6923         << getOpenMPDirectiveName(CancelRegion);
6924     return StmtError();
6925   }
6926   if (DSAStack->isParentNowaitRegion()) {
6927     Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0;
6928     return StmtError();
6929   }
6930   if (DSAStack->isParentOrderedRegion()) {
6931     Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0;
6932     return StmtError();
6933   }
6934   return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc,
6935                                                CancelRegion);
6936 }
6937 
ActOnOpenMPCancelDirective(ArrayRef<OMPClause * > Clauses,SourceLocation StartLoc,SourceLocation EndLoc,OpenMPDirectiveKind CancelRegion)6938 StmtResult Sema::ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
6939                                             SourceLocation StartLoc,
6940                                             SourceLocation EndLoc,
6941                                             OpenMPDirectiveKind CancelRegion) {
6942   if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
6943       CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
6944     Diag(StartLoc, diag::err_omp_wrong_cancel_region)
6945         << getOpenMPDirectiveName(CancelRegion);
6946     return StmtError();
6947   }
6948   if (DSAStack->isParentNowaitRegion()) {
6949     Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1;
6950     return StmtError();
6951   }
6952   if (DSAStack->isParentOrderedRegion()) {
6953     Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1;
6954     return StmtError();
6955   }
6956   DSAStack->setParentCancelRegion(/*Cancel=*/true);
6957   return OMPCancelDirective::Create(Context, StartLoc, EndLoc, Clauses,
6958                                     CancelRegion);
6959 }
6960 
checkGrainsizeNumTasksClauses(Sema & S,ArrayRef<OMPClause * > Clauses)6961 static bool checkGrainsizeNumTasksClauses(Sema &S,
6962                                           ArrayRef<OMPClause *> Clauses) {
6963   OMPClause *PrevClause = nullptr;
6964   bool ErrorFound = false;
6965   for (auto *C : Clauses) {
6966     if (C->getClauseKind() == OMPC_grainsize ||
6967         C->getClauseKind() == OMPC_num_tasks) {
6968       if (!PrevClause)
6969         PrevClause = C;
6970       else if (PrevClause->getClauseKind() != C->getClauseKind()) {
6971         S.Diag(C->getLocStart(),
6972                diag::err_omp_grainsize_num_tasks_mutually_exclusive)
6973             << getOpenMPClauseName(C->getClauseKind())
6974             << getOpenMPClauseName(PrevClause->getClauseKind());
6975         S.Diag(PrevClause->getLocStart(),
6976                diag::note_omp_previous_grainsize_num_tasks)
6977             << getOpenMPClauseName(PrevClause->getClauseKind());
6978         ErrorFound = true;
6979       }
6980     }
6981   }
6982   return ErrorFound;
6983 }
6984 
ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)6985 StmtResult Sema::ActOnOpenMPTaskLoopDirective(
6986     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6987     SourceLocation EndLoc,
6988     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6989   if (!AStmt)
6990     return StmtError();
6991 
6992   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6993   OMPLoopDirective::HelperExprs B;
6994   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6995   // define the nested loops number.
6996   unsigned NestedLoopCount =
6997       CheckOpenMPLoop(OMPD_taskloop, getCollapseNumberExpr(Clauses),
6998                       /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
6999                       VarsWithImplicitDSA, B);
7000   if (NestedLoopCount == 0)
7001     return StmtError();
7002 
7003   assert((CurContext->isDependentContext() || B.builtAll()) &&
7004          "omp for loop exprs were not built");
7005 
7006   // OpenMP, [2.9.2 taskloop Construct, Restrictions]
7007   // The grainsize clause and num_tasks clause are mutually exclusive and may
7008   // not appear on the same taskloop directive.
7009   if (checkGrainsizeNumTasksClauses(*this, Clauses))
7010     return StmtError();
7011 
7012   getCurFunction()->setHasBranchProtectedScope();
7013   return OMPTaskLoopDirective::Create(Context, StartLoc, EndLoc,
7014                                       NestedLoopCount, Clauses, AStmt, B);
7015 }
7016 
ActOnOpenMPTaskLoopSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)7017 StmtResult Sema::ActOnOpenMPTaskLoopSimdDirective(
7018     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7019     SourceLocation EndLoc,
7020     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7021   if (!AStmt)
7022     return StmtError();
7023 
7024   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
7025   OMPLoopDirective::HelperExprs B;
7026   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
7027   // define the nested loops number.
7028   unsigned NestedLoopCount =
7029       CheckOpenMPLoop(OMPD_taskloop_simd, getCollapseNumberExpr(Clauses),
7030                       /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
7031                       VarsWithImplicitDSA, B);
7032   if (NestedLoopCount == 0)
7033     return StmtError();
7034 
7035   assert((CurContext->isDependentContext() || B.builtAll()) &&
7036          "omp for loop exprs were not built");
7037 
7038   if (!CurContext->isDependentContext()) {
7039     // Finalize the clauses that need pre-built expressions for CodeGen.
7040     for (auto C : Clauses) {
7041       if (auto LC = dyn_cast<OMPLinearClause>(C))
7042         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
7043                                      B.NumIterations, *this, CurScope,
7044                                      DSAStack))
7045           return StmtError();
7046     }
7047   }
7048 
7049   // OpenMP, [2.9.2 taskloop Construct, Restrictions]
7050   // The grainsize clause and num_tasks clause are mutually exclusive and may
7051   // not appear on the same taskloop directive.
7052   if (checkGrainsizeNumTasksClauses(*this, Clauses))
7053     return StmtError();
7054 
7055   getCurFunction()->setHasBranchProtectedScope();
7056   return OMPTaskLoopSimdDirective::Create(Context, StartLoc, EndLoc,
7057                                           NestedLoopCount, Clauses, AStmt, B);
7058 }
7059 
ActOnOpenMPDistributeDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)7060 StmtResult Sema::ActOnOpenMPDistributeDirective(
7061     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7062     SourceLocation EndLoc,
7063     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7064   if (!AStmt)
7065     return StmtError();
7066 
7067   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
7068   OMPLoopDirective::HelperExprs B;
7069   // In presence of clause 'collapse' with number of loops, it will
7070   // define the nested loops number.
7071   unsigned NestedLoopCount =
7072       CheckOpenMPLoop(OMPD_distribute, getCollapseNumberExpr(Clauses),
7073                       nullptr /*ordered not a clause on distribute*/, AStmt,
7074                       *this, *DSAStack, VarsWithImplicitDSA, B);
7075   if (NestedLoopCount == 0)
7076     return StmtError();
7077 
7078   assert((CurContext->isDependentContext() || B.builtAll()) &&
7079          "omp for loop exprs were not built");
7080 
7081   getCurFunction()->setHasBranchProtectedScope();
7082   return OMPDistributeDirective::Create(Context, StartLoc, EndLoc,
7083                                         NestedLoopCount, Clauses, AStmt, B);
7084 }
7085 
ActOnOpenMPDistributeParallelForDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)7086 StmtResult Sema::ActOnOpenMPDistributeParallelForDirective(
7087     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7088     SourceLocation EndLoc,
7089     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7090   if (!AStmt)
7091     return StmtError();
7092 
7093   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7094   // 1.2.2 OpenMP Language Terminology
7095   // Structured block - An executable statement with a single entry at the
7096   // top and a single exit at the bottom.
7097   // The point of exit cannot be a branch out of the structured block.
7098   // longjmp() and throw() must not violate the entry/exit criteria.
7099   CS->getCapturedDecl()->setNothrow();
7100 
7101   OMPLoopDirective::HelperExprs B;
7102   // In presence of clause 'collapse' with number of loops, it will
7103   // define the nested loops number.
7104   unsigned NestedLoopCount = CheckOpenMPLoop(
7105       OMPD_distribute_parallel_for, getCollapseNumberExpr(Clauses),
7106       nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
7107       VarsWithImplicitDSA, B);
7108   if (NestedLoopCount == 0)
7109     return StmtError();
7110 
7111   assert((CurContext->isDependentContext() || B.builtAll()) &&
7112          "omp for loop exprs were not built");
7113 
7114   getCurFunction()->setHasBranchProtectedScope();
7115   return OMPDistributeParallelForDirective::Create(
7116       Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
7117 }
7118 
ActOnOpenMPDistributeParallelForSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)7119 StmtResult Sema::ActOnOpenMPDistributeParallelForSimdDirective(
7120     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7121     SourceLocation EndLoc,
7122     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7123   if (!AStmt)
7124     return StmtError();
7125 
7126   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7127   // 1.2.2 OpenMP Language Terminology
7128   // Structured block - An executable statement with a single entry at the
7129   // top and a single exit at the bottom.
7130   // The point of exit cannot be a branch out of the structured block.
7131   // longjmp() and throw() must not violate the entry/exit criteria.
7132   CS->getCapturedDecl()->setNothrow();
7133 
7134   OMPLoopDirective::HelperExprs B;
7135   // In presence of clause 'collapse' with number of loops, it will
7136   // define the nested loops number.
7137   unsigned NestedLoopCount = CheckOpenMPLoop(
7138       OMPD_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
7139       nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
7140       VarsWithImplicitDSA, B);
7141   if (NestedLoopCount == 0)
7142     return StmtError();
7143 
7144   assert((CurContext->isDependentContext() || B.builtAll()) &&
7145          "omp for loop exprs were not built");
7146 
7147   getCurFunction()->setHasBranchProtectedScope();
7148   return OMPDistributeParallelForSimdDirective::Create(
7149       Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
7150 }
7151 
ActOnOpenMPDistributeSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)7152 StmtResult Sema::ActOnOpenMPDistributeSimdDirective(
7153     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7154     SourceLocation EndLoc,
7155     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7156   if (!AStmt)
7157     return StmtError();
7158 
7159   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7160   // 1.2.2 OpenMP Language Terminology
7161   // Structured block - An executable statement with a single entry at the
7162   // top and a single exit at the bottom.
7163   // The point of exit cannot be a branch out of the structured block.
7164   // longjmp() and throw() must not violate the entry/exit criteria.
7165   CS->getCapturedDecl()->setNothrow();
7166 
7167   OMPLoopDirective::HelperExprs B;
7168   // In presence of clause 'collapse' with number of loops, it will
7169   // define the nested loops number.
7170   unsigned NestedLoopCount =
7171       CheckOpenMPLoop(OMPD_distribute_simd, getCollapseNumberExpr(Clauses),
7172                       nullptr /*ordered not a clause on distribute*/, AStmt,
7173                       *this, *DSAStack, VarsWithImplicitDSA, B);
7174   if (NestedLoopCount == 0)
7175     return StmtError();
7176 
7177   assert((CurContext->isDependentContext() || B.builtAll()) &&
7178          "omp for loop exprs were not built");
7179 
7180   getCurFunction()->setHasBranchProtectedScope();
7181   return OMPDistributeSimdDirective::Create(Context, StartLoc, EndLoc,
7182                                             NestedLoopCount, Clauses, AStmt, B);
7183 }
7184 
ActOnOpenMPTargetParallelForSimdDirective(ArrayRef<OMPClause * > Clauses,Stmt * AStmt,SourceLocation StartLoc,SourceLocation EndLoc,llvm::DenseMap<ValueDecl *,Expr * > & VarsWithImplicitDSA)7185 StmtResult Sema::ActOnOpenMPTargetParallelForSimdDirective(
7186     ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7187     SourceLocation EndLoc,
7188     llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7189   if (!AStmt)
7190     return StmtError();
7191 
7192   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7193   // 1.2.2 OpenMP Language Terminology
7194   // Structured block - An executable statement with a single entry at the
7195   // top and a single exit at the bottom.
7196   // The point of exit cannot be a branch out of the structured block.
7197   // longjmp() and throw() must not violate the entry/exit criteria.
7198   CS->getCapturedDecl()->setNothrow();
7199 
7200   OMPLoopDirective::HelperExprs B;
7201   // In presence of clause 'collapse' or 'ordered' with number of loops, it will
7202   // define the nested loops number.
7203   unsigned NestedLoopCount = CheckOpenMPLoop(
7204       OMPD_target_parallel_for_simd, getCollapseNumberExpr(Clauses),
7205       getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
7206       VarsWithImplicitDSA, B);
7207   if (NestedLoopCount == 0)
7208     return StmtError();
7209 
7210   assert((CurContext->isDependentContext() || B.builtAll()) &&
7211          "omp target parallel for simd loop exprs were not built");
7212 
7213   if (!CurContext->isDependentContext()) {
7214     // Finalize the clauses that need pre-built expressions for CodeGen.
7215     for (auto C : Clauses) {
7216       if (auto LC = dyn_cast<OMPLinearClause>(C))
7217         if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
7218                                      B.NumIterations, *this, CurScope,
7219                                      DSAStack))
7220           return StmtError();
7221     }
7222   }
7223 
7224   // OpenMP 4.1 [2.8.1, simd Construct, Restrictions]
7225   // If both simdlen and safelen clauses are specified, the value of the simdlen
7226   // parameter must be less than or equal to the value of the safelen parameter.
7227   OMPSafelenClause *Safelen = nullptr;
7228   OMPSimdlenClause *Simdlen = nullptr;
7229   for (auto *Clause : Clauses) {
7230     if (Clause->getClauseKind() == OMPC_safelen)
7231       Safelen = cast<OMPSafelenClause>(Clause);
7232     else if (Clause->getClauseKind() == OMPC_simdlen)
7233       Simdlen = cast<OMPSimdlenClause>(Clause);
7234     if (Safelen && Simdlen)
7235       break;
7236   }
7237   if (Simdlen && Safelen &&
7238       checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(),
7239                                 Safelen->getSafelen()))
7240     return StmtError();
7241 
7242   getCurFunction()->setHasBranchProtectedScope();
7243   return OMPTargetParallelForSimdDirective::Create(
7244       Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
7245 }
7246 
ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,Expr * Expr,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7247 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
7248                                              SourceLocation StartLoc,
7249                                              SourceLocation LParenLoc,
7250                                              SourceLocation EndLoc) {
7251   OMPClause *Res = nullptr;
7252   switch (Kind) {
7253   case OMPC_final:
7254     Res = ActOnOpenMPFinalClause(Expr, StartLoc, LParenLoc, EndLoc);
7255     break;
7256   case OMPC_num_threads:
7257     Res = ActOnOpenMPNumThreadsClause(Expr, StartLoc, LParenLoc, EndLoc);
7258     break;
7259   case OMPC_safelen:
7260     Res = ActOnOpenMPSafelenClause(Expr, StartLoc, LParenLoc, EndLoc);
7261     break;
7262   case OMPC_simdlen:
7263     Res = ActOnOpenMPSimdlenClause(Expr, StartLoc, LParenLoc, EndLoc);
7264     break;
7265   case OMPC_collapse:
7266     Res = ActOnOpenMPCollapseClause(Expr, StartLoc, LParenLoc, EndLoc);
7267     break;
7268   case OMPC_ordered:
7269     Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Expr);
7270     break;
7271   case OMPC_device:
7272     Res = ActOnOpenMPDeviceClause(Expr, StartLoc, LParenLoc, EndLoc);
7273     break;
7274   case OMPC_num_teams:
7275     Res = ActOnOpenMPNumTeamsClause(Expr, StartLoc, LParenLoc, EndLoc);
7276     break;
7277   case OMPC_thread_limit:
7278     Res = ActOnOpenMPThreadLimitClause(Expr, StartLoc, LParenLoc, EndLoc);
7279     break;
7280   case OMPC_priority:
7281     Res = ActOnOpenMPPriorityClause(Expr, StartLoc, LParenLoc, EndLoc);
7282     break;
7283   case OMPC_grainsize:
7284     Res = ActOnOpenMPGrainsizeClause(Expr, StartLoc, LParenLoc, EndLoc);
7285     break;
7286   case OMPC_num_tasks:
7287     Res = ActOnOpenMPNumTasksClause(Expr, StartLoc, LParenLoc, EndLoc);
7288     break;
7289   case OMPC_hint:
7290     Res = ActOnOpenMPHintClause(Expr, StartLoc, LParenLoc, EndLoc);
7291     break;
7292   case OMPC_if:
7293   case OMPC_default:
7294   case OMPC_proc_bind:
7295   case OMPC_schedule:
7296   case OMPC_private:
7297   case OMPC_firstprivate:
7298   case OMPC_lastprivate:
7299   case OMPC_shared:
7300   case OMPC_reduction:
7301   case OMPC_linear:
7302   case OMPC_aligned:
7303   case OMPC_copyin:
7304   case OMPC_copyprivate:
7305   case OMPC_nowait:
7306   case OMPC_untied:
7307   case OMPC_mergeable:
7308   case OMPC_threadprivate:
7309   case OMPC_flush:
7310   case OMPC_read:
7311   case OMPC_write:
7312   case OMPC_update:
7313   case OMPC_capture:
7314   case OMPC_seq_cst:
7315   case OMPC_depend:
7316   case OMPC_threads:
7317   case OMPC_simd:
7318   case OMPC_map:
7319   case OMPC_nogroup:
7320   case OMPC_dist_schedule:
7321   case OMPC_defaultmap:
7322   case OMPC_unknown:
7323   case OMPC_uniform:
7324   case OMPC_to:
7325   case OMPC_from:
7326   case OMPC_use_device_ptr:
7327   case OMPC_is_device_ptr:
7328     llvm_unreachable("Clause is not allowed.");
7329   }
7330   return Res;
7331 }
7332 
ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,Expr * Condition,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation NameModifierLoc,SourceLocation ColonLoc,SourceLocation EndLoc)7333 OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
7334                                      Expr *Condition, SourceLocation StartLoc,
7335                                      SourceLocation LParenLoc,
7336                                      SourceLocation NameModifierLoc,
7337                                      SourceLocation ColonLoc,
7338                                      SourceLocation EndLoc) {
7339   Expr *ValExpr = Condition;
7340   if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
7341       !Condition->isInstantiationDependent() &&
7342       !Condition->containsUnexpandedParameterPack()) {
7343     ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
7344     if (Val.isInvalid())
7345       return nullptr;
7346 
7347     ValExpr = MakeFullExpr(Val.get()).get();
7348   }
7349 
7350   return new (Context) OMPIfClause(NameModifier, ValExpr, StartLoc, LParenLoc,
7351                                    NameModifierLoc, ColonLoc, EndLoc);
7352 }
7353 
ActOnOpenMPFinalClause(Expr * Condition,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7354 OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition,
7355                                         SourceLocation StartLoc,
7356                                         SourceLocation LParenLoc,
7357                                         SourceLocation EndLoc) {
7358   Expr *ValExpr = Condition;
7359   if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
7360       !Condition->isInstantiationDependent() &&
7361       !Condition->containsUnexpandedParameterPack()) {
7362     ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
7363     if (Val.isInvalid())
7364       return nullptr;
7365 
7366     ValExpr = MakeFullExpr(Val.get()).get();
7367   }
7368 
7369   return new (Context) OMPFinalClause(ValExpr, StartLoc, LParenLoc, EndLoc);
7370 }
PerformOpenMPImplicitIntegerConversion(SourceLocation Loc,Expr * Op)7371 ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc,
7372                                                         Expr *Op) {
7373   if (!Op)
7374     return ExprError();
7375 
7376   class IntConvertDiagnoser : public ICEConvertDiagnoser {
7377   public:
7378     IntConvertDiagnoser()
7379         : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false, false, true) {}
7380     SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
7381                                          QualType T) override {
7382       return S.Diag(Loc, diag::err_omp_not_integral) << T;
7383     }
7384     SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
7385                                              QualType T) override {
7386       return S.Diag(Loc, diag::err_omp_incomplete_type) << T;
7387     }
7388     SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
7389                                                QualType T,
7390                                                QualType ConvTy) override {
7391       return S.Diag(Loc, diag::err_omp_explicit_conversion) << T << ConvTy;
7392     }
7393     SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
7394                                            QualType ConvTy) override {
7395       return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
7396              << ConvTy->isEnumeralType() << ConvTy;
7397     }
7398     SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
7399                                             QualType T) override {
7400       return S.Diag(Loc, diag::err_omp_ambiguous_conversion) << T;
7401     }
7402     SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
7403                                         QualType ConvTy) override {
7404       return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
7405              << ConvTy->isEnumeralType() << ConvTy;
7406     }
7407     SemaDiagnosticBuilder diagnoseConversion(Sema &, SourceLocation, QualType,
7408                                              QualType) override {
7409       llvm_unreachable("conversion functions are permitted");
7410     }
7411   } ConvertDiagnoser;
7412   return PerformContextualImplicitConversion(Loc, Op, ConvertDiagnoser);
7413 }
7414 
IsNonNegativeIntegerValue(Expr * & ValExpr,Sema & SemaRef,OpenMPClauseKind CKind,bool StrictlyPositive)7415 static bool IsNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef,
7416                                       OpenMPClauseKind CKind,
7417                                       bool StrictlyPositive) {
7418   if (!ValExpr->isTypeDependent() && !ValExpr->isValueDependent() &&
7419       !ValExpr->isInstantiationDependent()) {
7420     SourceLocation Loc = ValExpr->getExprLoc();
7421     ExprResult Value =
7422         SemaRef.PerformOpenMPImplicitIntegerConversion(Loc, ValExpr);
7423     if (Value.isInvalid())
7424       return false;
7425 
7426     ValExpr = Value.get();
7427     // The expression must evaluate to a non-negative integer value.
7428     llvm::APSInt Result;
7429     if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) &&
7430         Result.isSigned() &&
7431         !((!StrictlyPositive && Result.isNonNegative()) ||
7432           (StrictlyPositive && Result.isStrictlyPositive()))) {
7433       SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
7434           << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
7435           << ValExpr->getSourceRange();
7436       return false;
7437     }
7438   }
7439   return true;
7440 }
7441 
ActOnOpenMPNumThreadsClause(Expr * NumThreads,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7442 OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads,
7443                                              SourceLocation StartLoc,
7444                                              SourceLocation LParenLoc,
7445                                              SourceLocation EndLoc) {
7446   Expr *ValExpr = NumThreads;
7447 
7448   // OpenMP [2.5, Restrictions]
7449   //  The num_threads expression must evaluate to a positive integer value.
7450   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_threads,
7451                                  /*StrictlyPositive=*/true))
7452     return nullptr;
7453 
7454   return new (Context)
7455       OMPNumThreadsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
7456 }
7457 
VerifyPositiveIntegerConstantInClause(Expr * E,OpenMPClauseKind CKind,bool StrictlyPositive)7458 ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
7459                                                        OpenMPClauseKind CKind,
7460                                                        bool StrictlyPositive) {
7461   if (!E)
7462     return ExprError();
7463   if (E->isValueDependent() || E->isTypeDependent() ||
7464       E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
7465     return E;
7466   llvm::APSInt Result;
7467   ExprResult ICE = VerifyIntegerConstantExpression(E, &Result);
7468   if (ICE.isInvalid())
7469     return ExprError();
7470   if ((StrictlyPositive && !Result.isStrictlyPositive()) ||
7471       (!StrictlyPositive && !Result.isNonNegative())) {
7472     Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
7473         << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
7474         << E->getSourceRange();
7475     return ExprError();
7476   }
7477   if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
7478     Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
7479         << E->getSourceRange();
7480     return ExprError();
7481   }
7482   if (CKind == OMPC_collapse && DSAStack->getAssociatedLoops() == 1)
7483     DSAStack->setAssociatedLoops(Result.getExtValue());
7484   else if (CKind == OMPC_ordered)
7485     DSAStack->setAssociatedLoops(Result.getExtValue());
7486   return ICE;
7487 }
7488 
ActOnOpenMPSafelenClause(Expr * Len,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7489 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
7490                                           SourceLocation LParenLoc,
7491                                           SourceLocation EndLoc) {
7492   // OpenMP [2.8.1, simd construct, Description]
7493   // The parameter of the safelen clause must be a constant
7494   // positive integer expression.
7495   ExprResult Safelen = VerifyPositiveIntegerConstantInClause(Len, OMPC_safelen);
7496   if (Safelen.isInvalid())
7497     return nullptr;
7498   return new (Context)
7499       OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc);
7500 }
7501 
ActOnOpenMPSimdlenClause(Expr * Len,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7502 OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
7503                                           SourceLocation LParenLoc,
7504                                           SourceLocation EndLoc) {
7505   // OpenMP [2.8.1, simd construct, Description]
7506   // The parameter of the simdlen clause must be a constant
7507   // positive integer expression.
7508   ExprResult Simdlen = VerifyPositiveIntegerConstantInClause(Len, OMPC_simdlen);
7509   if (Simdlen.isInvalid())
7510     return nullptr;
7511   return new (Context)
7512       OMPSimdlenClause(Simdlen.get(), StartLoc, LParenLoc, EndLoc);
7513 }
7514 
ActOnOpenMPCollapseClause(Expr * NumForLoops,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7515 OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops,
7516                                            SourceLocation StartLoc,
7517                                            SourceLocation LParenLoc,
7518                                            SourceLocation EndLoc) {
7519   // OpenMP [2.7.1, loop construct, Description]
7520   // OpenMP [2.8.1, simd construct, Description]
7521   // OpenMP [2.9.6, distribute construct, Description]
7522   // The parameter of the collapse clause must be a constant
7523   // positive integer expression.
7524   ExprResult NumForLoopsResult =
7525       VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_collapse);
7526   if (NumForLoopsResult.isInvalid())
7527     return nullptr;
7528   return new (Context)
7529       OMPCollapseClause(NumForLoopsResult.get(), StartLoc, LParenLoc, EndLoc);
7530 }
7531 
ActOnOpenMPOrderedClause(SourceLocation StartLoc,SourceLocation EndLoc,SourceLocation LParenLoc,Expr * NumForLoops)7532 OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc,
7533                                           SourceLocation EndLoc,
7534                                           SourceLocation LParenLoc,
7535                                           Expr *NumForLoops) {
7536   // OpenMP [2.7.1, loop construct, Description]
7537   // OpenMP [2.8.1, simd construct, Description]
7538   // OpenMP [2.9.6, distribute construct, Description]
7539   // The parameter of the ordered clause must be a constant
7540   // positive integer expression if any.
7541   if (NumForLoops && LParenLoc.isValid()) {
7542     ExprResult NumForLoopsResult =
7543         VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered);
7544     if (NumForLoopsResult.isInvalid())
7545       return nullptr;
7546     NumForLoops = NumForLoopsResult.get();
7547   } else
7548     NumForLoops = nullptr;
7549   DSAStack->setOrderedRegion(/*IsOrdered=*/true, NumForLoops);
7550   return new (Context)
7551       OMPOrderedClause(NumForLoops, StartLoc, LParenLoc, EndLoc);
7552 }
7553 
ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,unsigned Argument,SourceLocation ArgumentLoc,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7554 OMPClause *Sema::ActOnOpenMPSimpleClause(
7555     OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc,
7556     SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {
7557   OMPClause *Res = nullptr;
7558   switch (Kind) {
7559   case OMPC_default:
7560     Res =
7561         ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument),
7562                                  ArgumentLoc, StartLoc, LParenLoc, EndLoc);
7563     break;
7564   case OMPC_proc_bind:
7565     Res = ActOnOpenMPProcBindClause(
7566         static_cast<OpenMPProcBindClauseKind>(Argument), ArgumentLoc, StartLoc,
7567         LParenLoc, EndLoc);
7568     break;
7569   case OMPC_if:
7570   case OMPC_final:
7571   case OMPC_num_threads:
7572   case OMPC_safelen:
7573   case OMPC_simdlen:
7574   case OMPC_collapse:
7575   case OMPC_schedule:
7576   case OMPC_private:
7577   case OMPC_firstprivate:
7578   case OMPC_lastprivate:
7579   case OMPC_shared:
7580   case OMPC_reduction:
7581   case OMPC_linear:
7582   case OMPC_aligned:
7583   case OMPC_copyin:
7584   case OMPC_copyprivate:
7585   case OMPC_ordered:
7586   case OMPC_nowait:
7587   case OMPC_untied:
7588   case OMPC_mergeable:
7589   case OMPC_threadprivate:
7590   case OMPC_flush:
7591   case OMPC_read:
7592   case OMPC_write:
7593   case OMPC_update:
7594   case OMPC_capture:
7595   case OMPC_seq_cst:
7596   case OMPC_depend:
7597   case OMPC_device:
7598   case OMPC_threads:
7599   case OMPC_simd:
7600   case OMPC_map:
7601   case OMPC_num_teams:
7602   case OMPC_thread_limit:
7603   case OMPC_priority:
7604   case OMPC_grainsize:
7605   case OMPC_nogroup:
7606   case OMPC_num_tasks:
7607   case OMPC_hint:
7608   case OMPC_dist_schedule:
7609   case OMPC_defaultmap:
7610   case OMPC_unknown:
7611   case OMPC_uniform:
7612   case OMPC_to:
7613   case OMPC_from:
7614   case OMPC_use_device_ptr:
7615   case OMPC_is_device_ptr:
7616     llvm_unreachable("Clause is not allowed.");
7617   }
7618   return Res;
7619 }
7620 
7621 static std::string
getListOfPossibleValues(OpenMPClauseKind K,unsigned First,unsigned Last,ArrayRef<unsigned> Exclude=llvm::None)7622 getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last,
7623                         ArrayRef<unsigned> Exclude = llvm::None) {
7624   std::string Values;
7625   unsigned Bound = Last >= 2 ? Last - 2 : 0;
7626   unsigned Skipped = Exclude.size();
7627   auto S = Exclude.begin(), E = Exclude.end();
7628   for (unsigned i = First; i < Last; ++i) {
7629     if (std::find(S, E, i) != E) {
7630       --Skipped;
7631       continue;
7632     }
7633     Values += "'";
7634     Values += getOpenMPSimpleClauseTypeName(K, i);
7635     Values += "'";
7636     if (i == Bound - Skipped)
7637       Values += " or ";
7638     else if (i != Bound + 1 - Skipped)
7639       Values += ", ";
7640   }
7641   return Values;
7642 }
7643 
ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,SourceLocation KindKwLoc,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7644 OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
7645                                           SourceLocation KindKwLoc,
7646                                           SourceLocation StartLoc,
7647                                           SourceLocation LParenLoc,
7648                                           SourceLocation EndLoc) {
7649   if (Kind == OMPC_DEFAULT_unknown) {
7650     static_assert(OMPC_DEFAULT_unknown > 0,
7651                   "OMPC_DEFAULT_unknown not greater than 0");
7652     Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
7653         << getListOfPossibleValues(OMPC_default, /*First=*/0,
7654                                    /*Last=*/OMPC_DEFAULT_unknown)
7655         << getOpenMPClauseName(OMPC_default);
7656     return nullptr;
7657   }
7658   switch (Kind) {
7659   case OMPC_DEFAULT_none:
7660     DSAStack->setDefaultDSANone(KindKwLoc);
7661     break;
7662   case OMPC_DEFAULT_shared:
7663     DSAStack->setDefaultDSAShared(KindKwLoc);
7664     break;
7665   case OMPC_DEFAULT_unknown:
7666     llvm_unreachable("Clause kind is not allowed.");
7667     break;
7668   }
7669   return new (Context)
7670       OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
7671 }
7672 
ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,SourceLocation KindKwLoc,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)7673 OMPClause *Sema::ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
7674                                            SourceLocation KindKwLoc,
7675                                            SourceLocation StartLoc,
7676                                            SourceLocation LParenLoc,
7677                                            SourceLocation EndLoc) {
7678   if (Kind == OMPC_PROC_BIND_unknown) {
7679     Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
7680         << getListOfPossibleValues(OMPC_proc_bind, /*First=*/0,
7681                                    /*Last=*/OMPC_PROC_BIND_unknown)
7682         << getOpenMPClauseName(OMPC_proc_bind);
7683     return nullptr;
7684   }
7685   return new (Context)
7686       OMPProcBindClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
7687 }
7688 
ActOnOpenMPSingleExprWithArgClause(OpenMPClauseKind Kind,ArrayRef<unsigned> Argument,Expr * Expr,SourceLocation StartLoc,SourceLocation LParenLoc,ArrayRef<SourceLocation> ArgumentLoc,SourceLocation DelimLoc,SourceLocation EndLoc)7689 OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
7690     OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
7691     SourceLocation StartLoc, SourceLocation LParenLoc,
7692     ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc,
7693     SourceLocation EndLoc) {
7694   OMPClause *Res = nullptr;
7695   switch (Kind) {
7696   case OMPC_schedule:
7697     enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
7698     assert(Argument.size() == NumberOfElements &&
7699            ArgumentLoc.size() == NumberOfElements);
7700     Res = ActOnOpenMPScheduleClause(
7701         static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier1]),
7702         static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier2]),
7703         static_cast<OpenMPScheduleClauseKind>(Argument[ScheduleKind]), Expr,
7704         StartLoc, LParenLoc, ArgumentLoc[Modifier1], ArgumentLoc[Modifier2],
7705         ArgumentLoc[ScheduleKind], DelimLoc, EndLoc);
7706     break;
7707   case OMPC_if:
7708     assert(Argument.size() == 1 && ArgumentLoc.size() == 1);
7709     Res = ActOnOpenMPIfClause(static_cast<OpenMPDirectiveKind>(Argument.back()),
7710                               Expr, StartLoc, LParenLoc, ArgumentLoc.back(),
7711                               DelimLoc, EndLoc);
7712     break;
7713   case OMPC_dist_schedule:
7714     Res = ActOnOpenMPDistScheduleClause(
7715         static_cast<OpenMPDistScheduleClauseKind>(Argument.back()), Expr,
7716         StartLoc, LParenLoc, ArgumentLoc.back(), DelimLoc, EndLoc);
7717     break;
7718   case OMPC_defaultmap:
7719     enum { Modifier, DefaultmapKind };
7720     Res = ActOnOpenMPDefaultmapClause(
7721         static_cast<OpenMPDefaultmapClauseModifier>(Argument[Modifier]),
7722         static_cast<OpenMPDefaultmapClauseKind>(Argument[DefaultmapKind]),
7723         StartLoc, LParenLoc, ArgumentLoc[Modifier],
7724         ArgumentLoc[DefaultmapKind], EndLoc);
7725     break;
7726   case OMPC_final:
7727   case OMPC_num_threads:
7728   case OMPC_safelen:
7729   case OMPC_simdlen:
7730   case OMPC_collapse:
7731   case OMPC_default:
7732   case OMPC_proc_bind:
7733   case OMPC_private:
7734   case OMPC_firstprivate:
7735   case OMPC_lastprivate:
7736   case OMPC_shared:
7737   case OMPC_reduction:
7738   case OMPC_linear:
7739   case OMPC_aligned:
7740   case OMPC_copyin:
7741   case OMPC_copyprivate:
7742   case OMPC_ordered:
7743   case OMPC_nowait:
7744   case OMPC_untied:
7745   case OMPC_mergeable:
7746   case OMPC_threadprivate:
7747   case OMPC_flush:
7748   case OMPC_read:
7749   case OMPC_write:
7750   case OMPC_update:
7751   case OMPC_capture:
7752   case OMPC_seq_cst:
7753   case OMPC_depend:
7754   case OMPC_device:
7755   case OMPC_threads:
7756   case OMPC_simd:
7757   case OMPC_map:
7758   case OMPC_num_teams:
7759   case OMPC_thread_limit:
7760   case OMPC_priority:
7761   case OMPC_grainsize:
7762   case OMPC_nogroup:
7763   case OMPC_num_tasks:
7764   case OMPC_hint:
7765   case OMPC_unknown:
7766   case OMPC_uniform:
7767   case OMPC_to:
7768   case OMPC_from:
7769   case OMPC_use_device_ptr:
7770   case OMPC_is_device_ptr:
7771     llvm_unreachable("Clause is not allowed.");
7772   }
7773   return Res;
7774 }
7775 
checkScheduleModifiers(Sema & S,OpenMPScheduleClauseModifier M1,OpenMPScheduleClauseModifier M2,SourceLocation M1Loc,SourceLocation M2Loc)7776 static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1,
7777                                    OpenMPScheduleClauseModifier M2,
7778                                    SourceLocation M1Loc, SourceLocation M2Loc) {
7779   if (M1 == OMPC_SCHEDULE_MODIFIER_unknown && M1Loc.isValid()) {
7780     SmallVector<unsigned, 2> Excluded;
7781     if (M2 != OMPC_SCHEDULE_MODIFIER_unknown)
7782       Excluded.push_back(M2);
7783     if (M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic)
7784       Excluded.push_back(OMPC_SCHEDULE_MODIFIER_monotonic);
7785     if (M2 == OMPC_SCHEDULE_MODIFIER_monotonic)
7786       Excluded.push_back(OMPC_SCHEDULE_MODIFIER_nonmonotonic);
7787     S.Diag(M1Loc, diag::err_omp_unexpected_clause_value)
7788         << getListOfPossibleValues(OMPC_schedule,
7789                                    /*First=*/OMPC_SCHEDULE_MODIFIER_unknown + 1,
7790                                    /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7791                                    Excluded)
7792         << getOpenMPClauseName(OMPC_schedule);
7793     return true;
7794   }
7795   return false;
7796 }
7797 
ActOnOpenMPScheduleClause(OpenMPScheduleClauseModifier M1,OpenMPScheduleClauseModifier M2,OpenMPScheduleClauseKind Kind,Expr * ChunkSize,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation M1Loc,SourceLocation M2Loc,SourceLocation KindLoc,SourceLocation CommaLoc,SourceLocation EndLoc)7798 OMPClause *Sema::ActOnOpenMPScheduleClause(
7799     OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
7800     OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
7801     SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
7802     SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
7803   if (checkScheduleModifiers(*this, M1, M2, M1Loc, M2Loc) ||
7804       checkScheduleModifiers(*this, M2, M1, M2Loc, M1Loc))
7805     return nullptr;
7806   // OpenMP, 2.7.1, Loop Construct, Restrictions
7807   // Either the monotonic modifier or the nonmonotonic modifier can be specified
7808   // but not both.
7809   if ((M1 == M2 && M1 != OMPC_SCHEDULE_MODIFIER_unknown) ||
7810       (M1 == OMPC_SCHEDULE_MODIFIER_monotonic &&
7811        M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) ||
7812       (M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic &&
7813        M2 == OMPC_SCHEDULE_MODIFIER_monotonic)) {
7814     Diag(M2Loc, diag::err_omp_unexpected_schedule_modifier)
7815         << getOpenMPSimpleClauseTypeName(OMPC_schedule, M2)
7816         << getOpenMPSimpleClauseTypeName(OMPC_schedule, M1);
7817     return nullptr;
7818   }
7819   if (Kind == OMPC_SCHEDULE_unknown) {
7820     std::string Values;
7821     if (M1Loc.isInvalid() && M2Loc.isInvalid()) {
7822       unsigned Exclude[] = {OMPC_SCHEDULE_unknown};
7823       Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7824                                        /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7825                                        Exclude);
7826     } else {
7827       Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7828                                        /*Last=*/OMPC_SCHEDULE_unknown);
7829     }
7830     Diag(KindLoc, diag::err_omp_unexpected_clause_value)
7831         << Values << getOpenMPClauseName(OMPC_schedule);
7832     return nullptr;
7833   }
7834   // OpenMP, 2.7.1, Loop Construct, Restrictions
7835   // The nonmonotonic modifier can only be specified with schedule(dynamic) or
7836   // schedule(guided).
7837   if ((M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
7838        M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
7839       Kind != OMPC_SCHEDULE_dynamic && Kind != OMPC_SCHEDULE_guided) {
7840     Diag(M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ? M1Loc : M2Loc,
7841          diag::err_omp_schedule_nonmonotonic_static);
7842     return nullptr;
7843   }
7844   Expr *ValExpr = ChunkSize;
7845   Stmt *HelperValStmt = nullptr;
7846   if (ChunkSize) {
7847     if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
7848         !ChunkSize->isInstantiationDependent() &&
7849         !ChunkSize->containsUnexpandedParameterPack()) {
7850       SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
7851       ExprResult Val =
7852           PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
7853       if (Val.isInvalid())
7854         return nullptr;
7855 
7856       ValExpr = Val.get();
7857 
7858       // OpenMP [2.7.1, Restrictions]
7859       //  chunk_size must be a loop invariant integer expression with a positive
7860       //  value.
7861       llvm::APSInt Result;
7862       if (ValExpr->isIntegerConstantExpr(Result, Context)) {
7863         if (Result.isSigned() && !Result.isStrictlyPositive()) {
7864           Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
7865               << "schedule" << 1 << ChunkSize->getSourceRange();
7866           return nullptr;
7867         }
7868       } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
7869                  !CurContext->isDependentContext()) {
7870         llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7871         ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7872         HelperValStmt = buildPreInits(Context, Captures);
7873       }
7874     }
7875   }
7876 
7877   return new (Context)
7878       OMPScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, Kind,
7879                         ValExpr, HelperValStmt, M1, M1Loc, M2, M2Loc);
7880 }
7881 
ActOnOpenMPClause(OpenMPClauseKind Kind,SourceLocation StartLoc,SourceLocation EndLoc)7882 OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
7883                                    SourceLocation StartLoc,
7884                                    SourceLocation EndLoc) {
7885   OMPClause *Res = nullptr;
7886   switch (Kind) {
7887   case OMPC_ordered:
7888     Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc);
7889     break;
7890   case OMPC_nowait:
7891     Res = ActOnOpenMPNowaitClause(StartLoc, EndLoc);
7892     break;
7893   case OMPC_untied:
7894     Res = ActOnOpenMPUntiedClause(StartLoc, EndLoc);
7895     break;
7896   case OMPC_mergeable:
7897     Res = ActOnOpenMPMergeableClause(StartLoc, EndLoc);
7898     break;
7899   case OMPC_read:
7900     Res = ActOnOpenMPReadClause(StartLoc, EndLoc);
7901     break;
7902   case OMPC_write:
7903     Res = ActOnOpenMPWriteClause(StartLoc, EndLoc);
7904     break;
7905   case OMPC_update:
7906     Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc);
7907     break;
7908   case OMPC_capture:
7909     Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc);
7910     break;
7911   case OMPC_seq_cst:
7912     Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
7913     break;
7914   case OMPC_threads:
7915     Res = ActOnOpenMPThreadsClause(StartLoc, EndLoc);
7916     break;
7917   case OMPC_simd:
7918     Res = ActOnOpenMPSIMDClause(StartLoc, EndLoc);
7919     break;
7920   case OMPC_nogroup:
7921     Res = ActOnOpenMPNogroupClause(StartLoc, EndLoc);
7922     break;
7923   case OMPC_if:
7924   case OMPC_final:
7925   case OMPC_num_threads:
7926   case OMPC_safelen:
7927   case OMPC_simdlen:
7928   case OMPC_collapse:
7929   case OMPC_schedule:
7930   case OMPC_private:
7931   case OMPC_firstprivate:
7932   case OMPC_lastprivate:
7933   case OMPC_shared:
7934   case OMPC_reduction:
7935   case OMPC_linear:
7936   case OMPC_aligned:
7937   case OMPC_copyin:
7938   case OMPC_copyprivate:
7939   case OMPC_default:
7940   case OMPC_proc_bind:
7941   case OMPC_threadprivate:
7942   case OMPC_flush:
7943   case OMPC_depend:
7944   case OMPC_device:
7945   case OMPC_map:
7946   case OMPC_num_teams:
7947   case OMPC_thread_limit:
7948   case OMPC_priority:
7949   case OMPC_grainsize:
7950   case OMPC_num_tasks:
7951   case OMPC_hint:
7952   case OMPC_dist_schedule:
7953   case OMPC_defaultmap:
7954   case OMPC_unknown:
7955   case OMPC_uniform:
7956   case OMPC_to:
7957   case OMPC_from:
7958   case OMPC_use_device_ptr:
7959   case OMPC_is_device_ptr:
7960     llvm_unreachable("Clause is not allowed.");
7961   }
7962   return Res;
7963 }
7964 
ActOnOpenMPNowaitClause(SourceLocation StartLoc,SourceLocation EndLoc)7965 OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc,
7966                                          SourceLocation EndLoc) {
7967   DSAStack->setNowaitRegion();
7968   return new (Context) OMPNowaitClause(StartLoc, EndLoc);
7969 }
7970 
ActOnOpenMPUntiedClause(SourceLocation StartLoc,SourceLocation EndLoc)7971 OMPClause *Sema::ActOnOpenMPUntiedClause(SourceLocation StartLoc,
7972                                          SourceLocation EndLoc) {
7973   return new (Context) OMPUntiedClause(StartLoc, EndLoc);
7974 }
7975 
ActOnOpenMPMergeableClause(SourceLocation StartLoc,SourceLocation EndLoc)7976 OMPClause *Sema::ActOnOpenMPMergeableClause(SourceLocation StartLoc,
7977                                             SourceLocation EndLoc) {
7978   return new (Context) OMPMergeableClause(StartLoc, EndLoc);
7979 }
7980 
ActOnOpenMPReadClause(SourceLocation StartLoc,SourceLocation EndLoc)7981 OMPClause *Sema::ActOnOpenMPReadClause(SourceLocation StartLoc,
7982                                        SourceLocation EndLoc) {
7983   return new (Context) OMPReadClause(StartLoc, EndLoc);
7984 }
7985 
ActOnOpenMPWriteClause(SourceLocation StartLoc,SourceLocation EndLoc)7986 OMPClause *Sema::ActOnOpenMPWriteClause(SourceLocation StartLoc,
7987                                         SourceLocation EndLoc) {
7988   return new (Context) OMPWriteClause(StartLoc, EndLoc);
7989 }
7990 
ActOnOpenMPUpdateClause(SourceLocation StartLoc,SourceLocation EndLoc)7991 OMPClause *Sema::ActOnOpenMPUpdateClause(SourceLocation StartLoc,
7992                                          SourceLocation EndLoc) {
7993   return new (Context) OMPUpdateClause(StartLoc, EndLoc);
7994 }
7995 
ActOnOpenMPCaptureClause(SourceLocation StartLoc,SourceLocation EndLoc)7996 OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc,
7997                                           SourceLocation EndLoc) {
7998   return new (Context) OMPCaptureClause(StartLoc, EndLoc);
7999 }
8000 
ActOnOpenMPSeqCstClause(SourceLocation StartLoc,SourceLocation EndLoc)8001 OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
8002                                          SourceLocation EndLoc) {
8003   return new (Context) OMPSeqCstClause(StartLoc, EndLoc);
8004 }
8005 
ActOnOpenMPThreadsClause(SourceLocation StartLoc,SourceLocation EndLoc)8006 OMPClause *Sema::ActOnOpenMPThreadsClause(SourceLocation StartLoc,
8007                                           SourceLocation EndLoc) {
8008   return new (Context) OMPThreadsClause(StartLoc, EndLoc);
8009 }
8010 
ActOnOpenMPSIMDClause(SourceLocation StartLoc,SourceLocation EndLoc)8011 OMPClause *Sema::ActOnOpenMPSIMDClause(SourceLocation StartLoc,
8012                                        SourceLocation EndLoc) {
8013   return new (Context) OMPSIMDClause(StartLoc, EndLoc);
8014 }
8015 
ActOnOpenMPNogroupClause(SourceLocation StartLoc,SourceLocation EndLoc)8016 OMPClause *Sema::ActOnOpenMPNogroupClause(SourceLocation StartLoc,
8017                                           SourceLocation EndLoc) {
8018   return new (Context) OMPNogroupClause(StartLoc, EndLoc);
8019 }
8020 
ActOnOpenMPVarListClause(OpenMPClauseKind Kind,ArrayRef<Expr * > VarList,Expr * TailExpr,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,CXXScopeSpec & ReductionIdScopeSpec,const DeclarationNameInfo & ReductionId,OpenMPDependClauseKind DepKind,OpenMPLinearClauseKind LinKind,OpenMPMapClauseKind MapTypeModifier,OpenMPMapClauseKind MapType,bool IsMapTypeImplicit,SourceLocation DepLinMapLoc)8021 OMPClause *Sema::ActOnOpenMPVarListClause(
8022     OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
8023     SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc,
8024     SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
8025     const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
8026     OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
8027     OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
8028     SourceLocation DepLinMapLoc) {
8029   OMPClause *Res = nullptr;
8030   switch (Kind) {
8031   case OMPC_private:
8032     Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8033     break;
8034   case OMPC_firstprivate:
8035     Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8036     break;
8037   case OMPC_lastprivate:
8038     Res = ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8039     break;
8040   case OMPC_shared:
8041     Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc);
8042     break;
8043   case OMPC_reduction:
8044     Res = ActOnOpenMPReductionClause(VarList, StartLoc, LParenLoc, ColonLoc,
8045                                      EndLoc, ReductionIdScopeSpec, ReductionId);
8046     break;
8047   case OMPC_linear:
8048     Res = ActOnOpenMPLinearClause(VarList, TailExpr, StartLoc, LParenLoc,
8049                                   LinKind, DepLinMapLoc, ColonLoc, EndLoc);
8050     break;
8051   case OMPC_aligned:
8052     Res = ActOnOpenMPAlignedClause(VarList, TailExpr, StartLoc, LParenLoc,
8053                                    ColonLoc, EndLoc);
8054     break;
8055   case OMPC_copyin:
8056     Res = ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, EndLoc);
8057     break;
8058   case OMPC_copyprivate:
8059     Res = ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8060     break;
8061   case OMPC_flush:
8062     Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc);
8063     break;
8064   case OMPC_depend:
8065     Res = ActOnOpenMPDependClause(DepKind, DepLinMapLoc, ColonLoc, VarList,
8066                                   StartLoc, LParenLoc, EndLoc);
8067     break;
8068   case OMPC_map:
8069     Res = ActOnOpenMPMapClause(MapTypeModifier, MapType, IsMapTypeImplicit,
8070                                DepLinMapLoc, ColonLoc, VarList, StartLoc,
8071                                LParenLoc, EndLoc);
8072     break;
8073   case OMPC_to:
8074     Res = ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
8075     break;
8076   case OMPC_from:
8077     Res = ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc, EndLoc);
8078     break;
8079   case OMPC_use_device_ptr:
8080     Res = ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
8081     break;
8082   case OMPC_is_device_ptr:
8083     Res = ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
8084     break;
8085   case OMPC_if:
8086   case OMPC_final:
8087   case OMPC_num_threads:
8088   case OMPC_safelen:
8089   case OMPC_simdlen:
8090   case OMPC_collapse:
8091   case OMPC_default:
8092   case OMPC_proc_bind:
8093   case OMPC_schedule:
8094   case OMPC_ordered:
8095   case OMPC_nowait:
8096   case OMPC_untied:
8097   case OMPC_mergeable:
8098   case OMPC_threadprivate:
8099   case OMPC_read:
8100   case OMPC_write:
8101   case OMPC_update:
8102   case OMPC_capture:
8103   case OMPC_seq_cst:
8104   case OMPC_device:
8105   case OMPC_threads:
8106   case OMPC_simd:
8107   case OMPC_num_teams:
8108   case OMPC_thread_limit:
8109   case OMPC_priority:
8110   case OMPC_grainsize:
8111   case OMPC_nogroup:
8112   case OMPC_num_tasks:
8113   case OMPC_hint:
8114   case OMPC_dist_schedule:
8115   case OMPC_defaultmap:
8116   case OMPC_unknown:
8117   case OMPC_uniform:
8118     llvm_unreachable("Clause is not allowed.");
8119   }
8120   return Res;
8121 }
8122 
getOpenMPCapturedExpr(VarDecl * Capture,ExprValueKind VK,ExprObjectKind OK,SourceLocation Loc)8123 ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
8124                                        ExprObjectKind OK, SourceLocation Loc) {
8125   ExprResult Res = BuildDeclRefExpr(
8126       Capture, Capture->getType().getNonReferenceType(), VK_LValue, Loc);
8127   if (!Res.isUsable())
8128     return ExprError();
8129   if (OK == OK_Ordinary && !getLangOpts().CPlusPlus) {
8130     Res = CreateBuiltinUnaryOp(Loc, UO_Deref, Res.get());
8131     if (!Res.isUsable())
8132       return ExprError();
8133   }
8134   if (VK != VK_LValue && Res.get()->isGLValue()) {
8135     Res = DefaultLvalueConversion(Res.get());
8136     if (!Res.isUsable())
8137       return ExprError();
8138   }
8139   return Res;
8140 }
8141 
8142 static std::pair<ValueDecl *, bool>
getPrivateItem(Sema & S,Expr * & RefExpr,SourceLocation & ELoc,SourceRange & ERange,bool AllowArraySection=false)8143 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
8144                SourceRange &ERange, bool AllowArraySection = false) {
8145   if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() ||
8146       RefExpr->containsUnexpandedParameterPack())
8147     return std::make_pair(nullptr, true);
8148 
8149   // OpenMP [3.1, C/C++]
8150   //  A list item is a variable name.
8151   // OpenMP  [2.9.3.3, Restrictions, p.1]
8152   //  A variable that is part of another variable (as an array or
8153   //  structure element) cannot appear in a private clause.
8154   RefExpr = RefExpr->IgnoreParens();
8155   enum {
8156     NoArrayExpr = -1,
8157     ArraySubscript = 0,
8158     OMPArraySection = 1
8159   } IsArrayExpr = NoArrayExpr;
8160   if (AllowArraySection) {
8161     if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) {
8162       auto *Base = ASE->getBase()->IgnoreParenImpCasts();
8163       while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
8164         Base = TempASE->getBase()->IgnoreParenImpCasts();
8165       RefExpr = Base;
8166       IsArrayExpr = ArraySubscript;
8167     } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) {
8168       auto *Base = OASE->getBase()->IgnoreParenImpCasts();
8169       while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base))
8170         Base = TempOASE->getBase()->IgnoreParenImpCasts();
8171       while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
8172         Base = TempASE->getBase()->IgnoreParenImpCasts();
8173       RefExpr = Base;
8174       IsArrayExpr = OMPArraySection;
8175     }
8176   }
8177   ELoc = RefExpr->getExprLoc();
8178   ERange = RefExpr->getSourceRange();
8179   RefExpr = RefExpr->IgnoreParenImpCasts();
8180   auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
8181   auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr);
8182   if ((!DE || !isa<VarDecl>(DE->getDecl())) &&
8183       (S.getCurrentThisType().isNull() || !ME ||
8184        !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) ||
8185        !isa<FieldDecl>(ME->getMemberDecl()))) {
8186     if (IsArrayExpr != NoArrayExpr)
8187       S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr
8188                                                          << ERange;
8189     else {
8190       S.Diag(ELoc,
8191              AllowArraySection
8192                  ? diag::err_omp_expected_var_name_member_expr_or_array_item
8193                  : diag::err_omp_expected_var_name_member_expr)
8194           << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange;
8195     }
8196     return std::make_pair(nullptr, false);
8197   }
8198   return std::make_pair(DE ? DE->getDecl() : ME->getMemberDecl(), false);
8199 }
8200 
ActOnOpenMPPrivateClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)8201 OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
8202                                           SourceLocation StartLoc,
8203                                           SourceLocation LParenLoc,
8204                                           SourceLocation EndLoc) {
8205   SmallVector<Expr *, 8> Vars;
8206   SmallVector<Expr *, 8> PrivateCopies;
8207   for (auto &RefExpr : VarList) {
8208     assert(RefExpr && "NULL expr in OpenMP private clause.");
8209     SourceLocation ELoc;
8210     SourceRange ERange;
8211     Expr *SimpleRefExpr = RefExpr;
8212     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8213     if (Res.second) {
8214       // It will be analyzed later.
8215       Vars.push_back(RefExpr);
8216       PrivateCopies.push_back(nullptr);
8217     }
8218     ValueDecl *D = Res.first;
8219     if (!D)
8220       continue;
8221 
8222     QualType Type = D->getType();
8223     auto *VD = dyn_cast<VarDecl>(D);
8224 
8225     // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8226     //  A variable that appears in a private clause must not have an incomplete
8227     //  type or a reference type.
8228     if (RequireCompleteType(ELoc, Type, diag::err_omp_private_incomplete_type))
8229       continue;
8230     Type = Type.getNonReferenceType();
8231 
8232     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8233     // in a Construct]
8234     //  Variables with the predetermined data-sharing attributes may not be
8235     //  listed in data-sharing attributes clauses, except for the cases
8236     //  listed below. For these exceptions only, listing a predetermined
8237     //  variable in a data-sharing attribute clause is allowed and overrides
8238     //  the variable's predetermined data-sharing attributes.
8239     DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8240     if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) {
8241       Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8242                                           << getOpenMPClauseName(OMPC_private);
8243       ReportOriginalDSA(*this, DSAStack, D, DVar);
8244       continue;
8245     }
8246 
8247     // Variably modified types are not supported for tasks.
8248     if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
8249         isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) {
8250       Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
8251           << getOpenMPClauseName(OMPC_private) << Type
8252           << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8253       bool IsDecl =
8254           !VD ||
8255           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8256       Diag(D->getLocation(),
8257            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8258           << D;
8259       continue;
8260     }
8261 
8262     // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
8263     // A list item cannot appear in both a map clause and a data-sharing
8264     // attribute clause on the same construct
8265     if (DSAStack->getCurrentDirective() == OMPD_target) {
8266       if (DSAStack->checkMappableExprComponentListsForDecl(
8267               VD, /* CurrentRegionOnly = */ true,
8268               [&](OMPClauseMappableExprCommon::MappableExprComponentListRef)
8269                   -> bool { return true; })) {
8270         Diag(ELoc, diag::err_omp_variable_in_map_and_dsa)
8271             << getOpenMPClauseName(OMPC_private)
8272             << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8273         ReportOriginalDSA(*this, DSAStack, D, DVar);
8274         continue;
8275       }
8276     }
8277 
8278     // OpenMP [2.9.3.3, Restrictions, C/C++, p.1]
8279     //  A variable of class type (or array thereof) that appears in a private
8280     //  clause requires an accessible, unambiguous default constructor for the
8281     //  class type.
8282     // Generate helper private variable and initialize it with the default
8283     // value. The address of the original variable is replaced by the address of
8284     // the new private variable in CodeGen. This new variable is not added to
8285     // IdResolver, so the code in the OpenMP region uses original variable for
8286     // proper diagnostics.
8287     Type = Type.getUnqualifiedType();
8288     auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
8289                                   D->hasAttrs() ? &D->getAttrs() : nullptr);
8290     ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false);
8291     if (VDPrivate->isInvalidDecl())
8292       continue;
8293     auto VDPrivateRefExpr = buildDeclRefExpr(
8294         *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
8295 
8296     DeclRefExpr *Ref = nullptr;
8297     if (!VD && !CurContext->isDependentContext())
8298       Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8299     DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_private, Ref);
8300     Vars.push_back((VD || CurContext->isDependentContext())
8301                        ? RefExpr->IgnoreParens()
8302                        : Ref);
8303     PrivateCopies.push_back(VDPrivateRefExpr);
8304   }
8305 
8306   if (Vars.empty())
8307     return nullptr;
8308 
8309   return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
8310                                   PrivateCopies);
8311 }
8312 
8313 namespace {
8314 class DiagsUninitializedSeveretyRAII {
8315 private:
8316   DiagnosticsEngine &Diags;
8317   SourceLocation SavedLoc;
8318   bool IsIgnored;
8319 
8320 public:
DiagsUninitializedSeveretyRAII(DiagnosticsEngine & Diags,SourceLocation Loc,bool IsIgnored)8321   DiagsUninitializedSeveretyRAII(DiagnosticsEngine &Diags, SourceLocation Loc,
8322                                  bool IsIgnored)
8323       : Diags(Diags), SavedLoc(Loc), IsIgnored(IsIgnored) {
8324     if (!IsIgnored) {
8325       Diags.setSeverity(/*Diag*/ diag::warn_uninit_self_reference_in_init,
8326                         /*Map*/ diag::Severity::Ignored, Loc);
8327     }
8328   }
~DiagsUninitializedSeveretyRAII()8329   ~DiagsUninitializedSeveretyRAII() {
8330     if (!IsIgnored)
8331       Diags.popMappings(SavedLoc);
8332   }
8333 };
8334 }
8335 
ActOnOpenMPFirstprivateClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)8336 OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
8337                                                SourceLocation StartLoc,
8338                                                SourceLocation LParenLoc,
8339                                                SourceLocation EndLoc) {
8340   SmallVector<Expr *, 8> Vars;
8341   SmallVector<Expr *, 8> PrivateCopies;
8342   SmallVector<Expr *, 8> Inits;
8343   SmallVector<Decl *, 4> ExprCaptures;
8344   bool IsImplicitClause =
8345       StartLoc.isInvalid() && LParenLoc.isInvalid() && EndLoc.isInvalid();
8346   auto ImplicitClauseLoc = DSAStack->getConstructLoc();
8347 
8348   for (auto &RefExpr : VarList) {
8349     assert(RefExpr && "NULL expr in OpenMP firstprivate clause.");
8350     SourceLocation ELoc;
8351     SourceRange ERange;
8352     Expr *SimpleRefExpr = RefExpr;
8353     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8354     if (Res.second) {
8355       // It will be analyzed later.
8356       Vars.push_back(RefExpr);
8357       PrivateCopies.push_back(nullptr);
8358       Inits.push_back(nullptr);
8359     }
8360     ValueDecl *D = Res.first;
8361     if (!D)
8362       continue;
8363 
8364     ELoc = IsImplicitClause ? ImplicitClauseLoc : ELoc;
8365     QualType Type = D->getType();
8366     auto *VD = dyn_cast<VarDecl>(D);
8367 
8368     // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8369     //  A variable that appears in a private clause must not have an incomplete
8370     //  type or a reference type.
8371     if (RequireCompleteType(ELoc, Type,
8372                             diag::err_omp_firstprivate_incomplete_type))
8373       continue;
8374     Type = Type.getNonReferenceType();
8375 
8376     // OpenMP [2.9.3.4, Restrictions, C/C++, p.1]
8377     //  A variable of class type (or array thereof) that appears in a private
8378     //  clause requires an accessible, unambiguous copy constructor for the
8379     //  class type.
8380     auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
8381 
8382     // If an implicit firstprivate variable found it was checked already.
8383     DSAStackTy::DSAVarData TopDVar;
8384     if (!IsImplicitClause) {
8385       DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8386       TopDVar = DVar;
8387       bool IsConstant = ElemType.isConstant(Context);
8388       // OpenMP [2.4.13, Data-sharing Attribute Clauses]
8389       //  A list item that specifies a given variable may not appear in more
8390       // than one clause on the same directive, except that a variable may be
8391       //  specified in both firstprivate and lastprivate clauses.
8392       if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_firstprivate &&
8393           DVar.CKind != OMPC_lastprivate && DVar.RefExpr) {
8394         Diag(ELoc, diag::err_omp_wrong_dsa)
8395             << getOpenMPClauseName(DVar.CKind)
8396             << getOpenMPClauseName(OMPC_firstprivate);
8397         ReportOriginalDSA(*this, DSAStack, D, DVar);
8398         continue;
8399       }
8400 
8401       // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8402       // in a Construct]
8403       //  Variables with the predetermined data-sharing attributes may not be
8404       //  listed in data-sharing attributes clauses, except for the cases
8405       //  listed below. For these exceptions only, listing a predetermined
8406       //  variable in a data-sharing attribute clause is allowed and overrides
8407       //  the variable's predetermined data-sharing attributes.
8408       // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8409       // in a Construct, C/C++, p.2]
8410       //  Variables with const-qualified type having no mutable member may be
8411       //  listed in a firstprivate clause, even if they are static data members.
8412       if (!(IsConstant || (VD && VD->isStaticDataMember())) && !DVar.RefExpr &&
8413           DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared) {
8414         Diag(ELoc, diag::err_omp_wrong_dsa)
8415             << getOpenMPClauseName(DVar.CKind)
8416             << getOpenMPClauseName(OMPC_firstprivate);
8417         ReportOriginalDSA(*this, DSAStack, D, DVar);
8418         continue;
8419       }
8420 
8421       OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8422       // OpenMP [2.9.3.4, Restrictions, p.2]
8423       //  A list item that is private within a parallel region must not appear
8424       //  in a firstprivate clause on a worksharing construct if any of the
8425       //  worksharing regions arising from the worksharing construct ever bind
8426       //  to any of the parallel regions arising from the parallel construct.
8427       if (isOpenMPWorksharingDirective(CurrDir) &&
8428           !isOpenMPParallelDirective(CurrDir)) {
8429         DVar = DSAStack->getImplicitDSA(D, true);
8430         if (DVar.CKind != OMPC_shared &&
8431             (isOpenMPParallelDirective(DVar.DKind) ||
8432              DVar.DKind == OMPD_unknown)) {
8433           Diag(ELoc, diag::err_omp_required_access)
8434               << getOpenMPClauseName(OMPC_firstprivate)
8435               << getOpenMPClauseName(OMPC_shared);
8436           ReportOriginalDSA(*this, DSAStack, D, DVar);
8437           continue;
8438         }
8439       }
8440       // OpenMP [2.9.3.4, Restrictions, p.3]
8441       //  A list item that appears in a reduction clause of a parallel construct
8442       //  must not appear in a firstprivate clause on a worksharing or task
8443       //  construct if any of the worksharing or task regions arising from the
8444       //  worksharing or task construct ever bind to any of the parallel regions
8445       //  arising from the parallel construct.
8446       // OpenMP [2.9.3.4, Restrictions, p.4]
8447       //  A list item that appears in a reduction clause in worksharing
8448       //  construct must not appear in a firstprivate clause in a task construct
8449       //  encountered during execution of any of the worksharing regions arising
8450       //  from the worksharing construct.
8451       if (isOpenMPTaskingDirective(CurrDir)) {
8452         DVar = DSAStack->hasInnermostDSA(
8453             D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
8454             [](OpenMPDirectiveKind K) -> bool {
8455               return isOpenMPParallelDirective(K) ||
8456                      isOpenMPWorksharingDirective(K);
8457             },
8458             false);
8459         if (DVar.CKind == OMPC_reduction &&
8460             (isOpenMPParallelDirective(DVar.DKind) ||
8461              isOpenMPWorksharingDirective(DVar.DKind))) {
8462           Diag(ELoc, diag::err_omp_parallel_reduction_in_task_firstprivate)
8463               << getOpenMPDirectiveName(DVar.DKind);
8464           ReportOriginalDSA(*this, DSAStack, D, DVar);
8465           continue;
8466         }
8467       }
8468 
8469       // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
8470       // A list item that is private within a teams region must not appear in a
8471       // firstprivate clause on a distribute construct if any of the distribute
8472       // regions arising from the distribute construct ever bind to any of the
8473       // teams regions arising from the teams construct.
8474       // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
8475       // A list item that appears in a reduction clause of a teams construct
8476       // must not appear in a firstprivate clause on a distribute construct if
8477       // any of the distribute regions arising from the distribute construct
8478       // ever bind to any of the teams regions arising from the teams construct.
8479       // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
8480       // A list item may appear in a firstprivate or lastprivate clause but not
8481       // both.
8482       if (CurrDir == OMPD_distribute) {
8483         DVar = DSAStack->hasInnermostDSA(
8484             D, [](OpenMPClauseKind C) -> bool { return C == OMPC_private; },
8485             [](OpenMPDirectiveKind K) -> bool {
8486               return isOpenMPTeamsDirective(K);
8487             },
8488             false);
8489         if (DVar.CKind == OMPC_private && isOpenMPTeamsDirective(DVar.DKind)) {
8490           Diag(ELoc, diag::err_omp_firstprivate_distribute_private_teams);
8491           ReportOriginalDSA(*this, DSAStack, D, DVar);
8492           continue;
8493         }
8494         DVar = DSAStack->hasInnermostDSA(
8495             D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
8496             [](OpenMPDirectiveKind K) -> bool {
8497               return isOpenMPTeamsDirective(K);
8498             },
8499             false);
8500         if (DVar.CKind == OMPC_reduction &&
8501             isOpenMPTeamsDirective(DVar.DKind)) {
8502           Diag(ELoc, diag::err_omp_firstprivate_distribute_in_teams_reduction);
8503           ReportOriginalDSA(*this, DSAStack, D, DVar);
8504           continue;
8505         }
8506         DVar = DSAStack->getTopDSA(D, false);
8507         if (DVar.CKind == OMPC_lastprivate) {
8508           Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
8509           ReportOriginalDSA(*this, DSAStack, D, DVar);
8510           continue;
8511         }
8512       }
8513       // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
8514       // A list item cannot appear in both a map clause and a data-sharing
8515       // attribute clause on the same construct
8516       if (CurrDir == OMPD_target) {
8517         if (DSAStack->checkMappableExprComponentListsForDecl(
8518                 VD, /* CurrentRegionOnly = */ true,
8519                 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef)
8520                     -> bool { return true; })) {
8521           Diag(ELoc, diag::err_omp_variable_in_map_and_dsa)
8522               << getOpenMPClauseName(OMPC_firstprivate)
8523               << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8524           ReportOriginalDSA(*this, DSAStack, D, DVar);
8525           continue;
8526         }
8527       }
8528     }
8529 
8530     // Variably modified types are not supported for tasks.
8531     if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
8532         isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) {
8533       Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
8534           << getOpenMPClauseName(OMPC_firstprivate) << Type
8535           << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8536       bool IsDecl =
8537           !VD ||
8538           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8539       Diag(D->getLocation(),
8540            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8541           << D;
8542       continue;
8543     }
8544 
8545     Type = Type.getUnqualifiedType();
8546     auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
8547                                   D->hasAttrs() ? &D->getAttrs() : nullptr);
8548     // Generate helper private variable and initialize it with the value of the
8549     // original variable. The address of the original variable is replaced by
8550     // the address of the new private variable in the CodeGen. This new variable
8551     // is not added to IdResolver, so the code in the OpenMP region uses
8552     // original variable for proper diagnostics and variable capturing.
8553     Expr *VDInitRefExpr = nullptr;
8554     // For arrays generate initializer for single element and replace it by the
8555     // original array element in CodeGen.
8556     if (Type->isArrayType()) {
8557       auto VDInit =
8558           buildVarDecl(*this, RefExpr->getExprLoc(), ElemType, D->getName());
8559       VDInitRefExpr = buildDeclRefExpr(*this, VDInit, ElemType, ELoc);
8560       auto Init = DefaultLvalueConversion(VDInitRefExpr).get();
8561       ElemType = ElemType.getUnqualifiedType();
8562       auto *VDInitTemp = buildVarDecl(*this, RefExpr->getExprLoc(), ElemType,
8563                                       ".firstprivate.temp");
8564       InitializedEntity Entity =
8565           InitializedEntity::InitializeVariable(VDInitTemp);
8566       InitializationKind Kind = InitializationKind::CreateCopy(ELoc, ELoc);
8567 
8568       InitializationSequence InitSeq(*this, Entity, Kind, Init);
8569       ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Init);
8570       if (Result.isInvalid())
8571         VDPrivate->setInvalidDecl();
8572       else
8573         VDPrivate->setInit(Result.getAs<Expr>());
8574       // Remove temp variable declaration.
8575       Context.Deallocate(VDInitTemp);
8576     } else {
8577       auto *VDInit = buildVarDecl(*this, RefExpr->getExprLoc(), Type,
8578                                   ".firstprivate.temp");
8579       VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(),
8580                                        RefExpr->getExprLoc());
8581       AddInitializerToDecl(VDPrivate,
8582                            DefaultLvalueConversion(VDInitRefExpr).get(),
8583                            /*DirectInit=*/false, /*TypeMayContainAuto=*/false);
8584     }
8585     if (VDPrivate->isInvalidDecl()) {
8586       if (IsImplicitClause) {
8587         Diag(RefExpr->getExprLoc(),
8588              diag::note_omp_task_predetermined_firstprivate_here);
8589       }
8590       continue;
8591     }
8592     CurContext->addDecl(VDPrivate);
8593     auto VDPrivateRefExpr = buildDeclRefExpr(
8594         *this, VDPrivate, RefExpr->getType().getUnqualifiedType(),
8595         RefExpr->getExprLoc());
8596     DeclRefExpr *Ref = nullptr;
8597     if (!VD && !CurContext->isDependentContext()) {
8598       if (TopDVar.CKind == OMPC_lastprivate)
8599         Ref = TopDVar.PrivateCopy;
8600       else {
8601         Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8602         if (!IsOpenMPCapturedDecl(D))
8603           ExprCaptures.push_back(Ref->getDecl());
8604       }
8605     }
8606     DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref);
8607     Vars.push_back((VD || CurContext->isDependentContext())
8608                        ? RefExpr->IgnoreParens()
8609                        : Ref);
8610     PrivateCopies.push_back(VDPrivateRefExpr);
8611     Inits.push_back(VDInitRefExpr);
8612   }
8613 
8614   if (Vars.empty())
8615     return nullptr;
8616 
8617   return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8618                                        Vars, PrivateCopies, Inits,
8619                                        buildPreInits(Context, ExprCaptures));
8620 }
8621 
ActOnOpenMPLastprivateClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)8622 OMPClause *Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
8623                                               SourceLocation StartLoc,
8624                                               SourceLocation LParenLoc,
8625                                               SourceLocation EndLoc) {
8626   SmallVector<Expr *, 8> Vars;
8627   SmallVector<Expr *, 8> SrcExprs;
8628   SmallVector<Expr *, 8> DstExprs;
8629   SmallVector<Expr *, 8> AssignmentOps;
8630   SmallVector<Decl *, 4> ExprCaptures;
8631   SmallVector<Expr *, 4> ExprPostUpdates;
8632   for (auto &RefExpr : VarList) {
8633     assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8634     SourceLocation ELoc;
8635     SourceRange ERange;
8636     Expr *SimpleRefExpr = RefExpr;
8637     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8638     if (Res.second) {
8639       // It will be analyzed later.
8640       Vars.push_back(RefExpr);
8641       SrcExprs.push_back(nullptr);
8642       DstExprs.push_back(nullptr);
8643       AssignmentOps.push_back(nullptr);
8644     }
8645     ValueDecl *D = Res.first;
8646     if (!D)
8647       continue;
8648 
8649     QualType Type = D->getType();
8650     auto *VD = dyn_cast<VarDecl>(D);
8651 
8652     // OpenMP [2.14.3.5, Restrictions, C/C++, p.2]
8653     //  A variable that appears in a lastprivate clause must not have an
8654     //  incomplete type or a reference type.
8655     if (RequireCompleteType(ELoc, Type,
8656                             diag::err_omp_lastprivate_incomplete_type))
8657       continue;
8658     Type = Type.getNonReferenceType();
8659 
8660     // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
8661     // in a Construct]
8662     //  Variables with the predetermined data-sharing attributes may not be
8663     //  listed in data-sharing attributes clauses, except for the cases
8664     //  listed below.
8665     DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8666     if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_lastprivate &&
8667         DVar.CKind != OMPC_firstprivate &&
8668         (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
8669       Diag(ELoc, diag::err_omp_wrong_dsa)
8670           << getOpenMPClauseName(DVar.CKind)
8671           << getOpenMPClauseName(OMPC_lastprivate);
8672       ReportOriginalDSA(*this, DSAStack, D, DVar);
8673       continue;
8674     }
8675 
8676     OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8677     // OpenMP [2.14.3.5, Restrictions, p.2]
8678     // A list item that is private within a parallel region, or that appears in
8679     // the reduction clause of a parallel construct, must not appear in a
8680     // lastprivate clause on a worksharing construct if any of the corresponding
8681     // worksharing regions ever binds to any of the corresponding parallel
8682     // regions.
8683     DSAStackTy::DSAVarData TopDVar = DVar;
8684     if (isOpenMPWorksharingDirective(CurrDir) &&
8685         !isOpenMPParallelDirective(CurrDir)) {
8686       DVar = DSAStack->getImplicitDSA(D, true);
8687       if (DVar.CKind != OMPC_shared) {
8688         Diag(ELoc, diag::err_omp_required_access)
8689             << getOpenMPClauseName(OMPC_lastprivate)
8690             << getOpenMPClauseName(OMPC_shared);
8691         ReportOriginalDSA(*this, DSAStack, D, DVar);
8692         continue;
8693       }
8694     }
8695 
8696     // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
8697     // A list item may appear in a firstprivate or lastprivate clause but not
8698     // both.
8699     if (CurrDir == OMPD_distribute) {
8700       DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8701       if (DVar.CKind == OMPC_firstprivate) {
8702         Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
8703         ReportOriginalDSA(*this, DSAStack, D, DVar);
8704         continue;
8705       }
8706     }
8707 
8708     // OpenMP [2.14.3.5, Restrictions, C++, p.1,2]
8709     //  A variable of class type (or array thereof) that appears in a
8710     //  lastprivate clause requires an accessible, unambiguous default
8711     //  constructor for the class type, unless the list item is also specified
8712     //  in a firstprivate clause.
8713     //  A variable of class type (or array thereof) that appears in a
8714     //  lastprivate clause requires an accessible, unambiguous copy assignment
8715     //  operator for the class type.
8716     Type = Context.getBaseElementType(Type).getNonReferenceType();
8717     auto *SrcVD = buildVarDecl(*this, ERange.getBegin(),
8718                                Type.getUnqualifiedType(), ".lastprivate.src",
8719                                D->hasAttrs() ? &D->getAttrs() : nullptr);
8720     auto *PseudoSrcExpr =
8721         buildDeclRefExpr(*this, SrcVD, Type.getUnqualifiedType(), ELoc);
8722     auto *DstVD =
8723         buildVarDecl(*this, ERange.getBegin(), Type, ".lastprivate.dst",
8724                      D->hasAttrs() ? &D->getAttrs() : nullptr);
8725     auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc);
8726     // For arrays generate assignment operation for single element and replace
8727     // it by the original array element in CodeGen.
8728     auto AssignmentOp = BuildBinOp(/*S=*/nullptr, ELoc, BO_Assign,
8729                                    PseudoDstExpr, PseudoSrcExpr);
8730     if (AssignmentOp.isInvalid())
8731       continue;
8732     AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
8733                                        /*DiscardedValue=*/true);
8734     if (AssignmentOp.isInvalid())
8735       continue;
8736 
8737     DeclRefExpr *Ref = nullptr;
8738     if (!VD && !CurContext->isDependentContext()) {
8739       if (TopDVar.CKind == OMPC_firstprivate)
8740         Ref = TopDVar.PrivateCopy;
8741       else {
8742         Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8743         if (!IsOpenMPCapturedDecl(D))
8744           ExprCaptures.push_back(Ref->getDecl());
8745       }
8746       if (TopDVar.CKind == OMPC_firstprivate ||
8747           (!IsOpenMPCapturedDecl(D) &&
8748            Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>())) {
8749         ExprResult RefRes = DefaultLvalueConversion(Ref);
8750         if (!RefRes.isUsable())
8751           continue;
8752         ExprResult PostUpdateRes =
8753             BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, SimpleRefExpr,
8754                        RefRes.get());
8755         if (!PostUpdateRes.isUsable())
8756           continue;
8757         ExprPostUpdates.push_back(
8758             IgnoredValueConversions(PostUpdateRes.get()).get());
8759       }
8760     }
8761     DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_lastprivate, Ref);
8762     Vars.push_back((VD || CurContext->isDependentContext())
8763                        ? RefExpr->IgnoreParens()
8764                        : Ref);
8765     SrcExprs.push_back(PseudoSrcExpr);
8766     DstExprs.push_back(PseudoDstExpr);
8767     AssignmentOps.push_back(AssignmentOp.get());
8768   }
8769 
8770   if (Vars.empty())
8771     return nullptr;
8772 
8773   return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8774                                       Vars, SrcExprs, DstExprs, AssignmentOps,
8775                                       buildPreInits(Context, ExprCaptures),
8776                                       buildPostUpdate(*this, ExprPostUpdates));
8777 }
8778 
ActOnOpenMPSharedClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)8779 OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
8780                                          SourceLocation StartLoc,
8781                                          SourceLocation LParenLoc,
8782                                          SourceLocation EndLoc) {
8783   SmallVector<Expr *, 8> Vars;
8784   for (auto &RefExpr : VarList) {
8785     assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8786     SourceLocation ELoc;
8787     SourceRange ERange;
8788     Expr *SimpleRefExpr = RefExpr;
8789     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8790     if (Res.second) {
8791       // It will be analyzed later.
8792       Vars.push_back(RefExpr);
8793     }
8794     ValueDecl *D = Res.first;
8795     if (!D)
8796       continue;
8797 
8798     auto *VD = dyn_cast<VarDecl>(D);
8799     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8800     // in a Construct]
8801     //  Variables with the predetermined data-sharing attributes may not be
8802     //  listed in data-sharing attributes clauses, except for the cases
8803     //  listed below. For these exceptions only, listing a predetermined
8804     //  variable in a data-sharing attribute clause is allowed and overrides
8805     //  the variable's predetermined data-sharing attributes.
8806     DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8807     if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared &&
8808         DVar.RefExpr) {
8809       Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8810                                           << getOpenMPClauseName(OMPC_shared);
8811       ReportOriginalDSA(*this, DSAStack, D, DVar);
8812       continue;
8813     }
8814 
8815     DeclRefExpr *Ref = nullptr;
8816     if (!VD && IsOpenMPCapturedDecl(D) && !CurContext->isDependentContext())
8817       Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8818     DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_shared, Ref);
8819     Vars.push_back((VD || !Ref || CurContext->isDependentContext())
8820                        ? RefExpr->IgnoreParens()
8821                        : Ref);
8822   }
8823 
8824   if (Vars.empty())
8825     return nullptr;
8826 
8827   return OMPSharedClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars);
8828 }
8829 
8830 namespace {
8831 class DSARefChecker : public StmtVisitor<DSARefChecker, bool> {
8832   DSAStackTy *Stack;
8833 
8834 public:
VisitDeclRefExpr(DeclRefExpr * E)8835   bool VisitDeclRefExpr(DeclRefExpr *E) {
8836     if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) {
8837       DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, false);
8838       if (DVar.CKind == OMPC_shared && !DVar.RefExpr)
8839         return false;
8840       if (DVar.CKind != OMPC_unknown)
8841         return true;
8842       DSAStackTy::DSAVarData DVarPrivate = Stack->hasDSA(
8843           VD, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
8844           false);
8845       if (DVarPrivate.CKind != OMPC_unknown)
8846         return true;
8847       return false;
8848     }
8849     return false;
8850   }
VisitStmt(Stmt * S)8851   bool VisitStmt(Stmt *S) {
8852     for (auto Child : S->children()) {
8853       if (Child && Visit(Child))
8854         return true;
8855     }
8856     return false;
8857   }
DSARefChecker(DSAStackTy * S)8858   explicit DSARefChecker(DSAStackTy *S) : Stack(S) {}
8859 };
8860 } // namespace
8861 
8862 namespace {
8863 // Transform MemberExpression for specified FieldDecl of current class to
8864 // DeclRefExpr to specified OMPCapturedExprDecl.
8865 class TransformExprToCaptures : public TreeTransform<TransformExprToCaptures> {
8866   typedef TreeTransform<TransformExprToCaptures> BaseTransform;
8867   ValueDecl *Field;
8868   DeclRefExpr *CapturedExpr;
8869 
8870 public:
TransformExprToCaptures(Sema & SemaRef,ValueDecl * FieldDecl)8871   TransformExprToCaptures(Sema &SemaRef, ValueDecl *FieldDecl)
8872       : BaseTransform(SemaRef), Field(FieldDecl), CapturedExpr(nullptr) {}
8873 
TransformMemberExpr(MemberExpr * E)8874   ExprResult TransformMemberExpr(MemberExpr *E) {
8875     if (isa<CXXThisExpr>(E->getBase()->IgnoreParenImpCasts()) &&
8876         E->getMemberDecl() == Field) {
8877       CapturedExpr = buildCapture(SemaRef, Field, E, /*WithInit=*/false);
8878       return CapturedExpr;
8879     }
8880     return BaseTransform::TransformMemberExpr(E);
8881   }
getCapturedExpr()8882   DeclRefExpr *getCapturedExpr() { return CapturedExpr; }
8883 };
8884 } // namespace
8885 
8886 template <typename T>
filterLookupForUDR(SmallVectorImpl<UnresolvedSet<8>> & Lookups,const llvm::function_ref<T (ValueDecl *)> & Gen)8887 static T filterLookupForUDR(SmallVectorImpl<UnresolvedSet<8>> &Lookups,
8888                             const llvm::function_ref<T(ValueDecl *)> &Gen) {
8889   for (auto &Set : Lookups) {
8890     for (auto *D : Set) {
8891       if (auto Res = Gen(cast<ValueDecl>(D)))
8892         return Res;
8893     }
8894   }
8895   return T();
8896 }
8897 
8898 static ExprResult
buildDeclareReductionRef(Sema & SemaRef,SourceLocation Loc,SourceRange Range,Scope * S,CXXScopeSpec & ReductionIdScopeSpec,const DeclarationNameInfo & ReductionId,QualType Ty,CXXCastPath & BasePath,Expr * UnresolvedReduction)8899 buildDeclareReductionRef(Sema &SemaRef, SourceLocation Loc, SourceRange Range,
8900                          Scope *S, CXXScopeSpec &ReductionIdScopeSpec,
8901                          const DeclarationNameInfo &ReductionId, QualType Ty,
8902                          CXXCastPath &BasePath, Expr *UnresolvedReduction) {
8903   if (ReductionIdScopeSpec.isInvalid())
8904     return ExprError();
8905   SmallVector<UnresolvedSet<8>, 4> Lookups;
8906   if (S) {
8907     LookupResult Lookup(SemaRef, ReductionId, Sema::LookupOMPReductionName);
8908     Lookup.suppressDiagnostics();
8909     while (S && SemaRef.LookupParsedName(Lookup, S, &ReductionIdScopeSpec)) {
8910       auto *D = Lookup.getRepresentativeDecl();
8911       do {
8912         S = S->getParent();
8913       } while (S && !S->isDeclScope(D));
8914       if (S)
8915         S = S->getParent();
8916       Lookups.push_back(UnresolvedSet<8>());
8917       Lookups.back().append(Lookup.begin(), Lookup.end());
8918       Lookup.clear();
8919     }
8920   } else if (auto *ULE =
8921                  cast_or_null<UnresolvedLookupExpr>(UnresolvedReduction)) {
8922     Lookups.push_back(UnresolvedSet<8>());
8923     Decl *PrevD = nullptr;
8924     for(auto *D : ULE->decls()) {
8925       if (D == PrevD)
8926         Lookups.push_back(UnresolvedSet<8>());
8927       else if (auto *DRD = cast<OMPDeclareReductionDecl>(D))
8928         Lookups.back().addDecl(DRD);
8929       PrevD = D;
8930     }
8931   }
8932   if (Ty->isDependentType() || Ty->isInstantiationDependentType() ||
8933       Ty->containsUnexpandedParameterPack() ||
8934       filterLookupForUDR<bool>(Lookups, [](ValueDecl *D) -> bool {
8935         return !D->isInvalidDecl() &&
8936                (D->getType()->isDependentType() ||
8937                 D->getType()->isInstantiationDependentType() ||
8938                 D->getType()->containsUnexpandedParameterPack());
8939       })) {
8940     UnresolvedSet<8> ResSet;
8941     for (auto &Set : Lookups) {
8942       ResSet.append(Set.begin(), Set.end());
8943       // The last item marks the end of all declarations at the specified scope.
8944       ResSet.addDecl(Set[Set.size() - 1]);
8945     }
8946     return UnresolvedLookupExpr::Create(
8947         SemaRef.Context, /*NamingClass=*/nullptr,
8948         ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), ReductionId,
8949         /*ADL=*/true, /*Overloaded=*/true, ResSet.begin(), ResSet.end());
8950   }
8951   if (auto *VD = filterLookupForUDR<ValueDecl *>(
8952           Lookups, [&SemaRef, Ty](ValueDecl *D) -> ValueDecl * {
8953             if (!D->isInvalidDecl() &&
8954                 SemaRef.Context.hasSameType(D->getType(), Ty))
8955               return D;
8956             return nullptr;
8957           }))
8958     return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8959   if (auto *VD = filterLookupForUDR<ValueDecl *>(
8960           Lookups, [&SemaRef, Ty, Loc](ValueDecl *D) -> ValueDecl * {
8961             if (!D->isInvalidDecl() &&
8962                 SemaRef.IsDerivedFrom(Loc, Ty, D->getType()) &&
8963                 !Ty.isMoreQualifiedThan(D->getType()))
8964               return D;
8965             return nullptr;
8966           })) {
8967     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
8968                        /*DetectVirtual=*/false);
8969     if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) {
8970       if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType(
8971               VD->getType().getUnqualifiedType()))) {
8972         if (SemaRef.CheckBaseClassAccess(Loc, VD->getType(), Ty, Paths.front(),
8973                                          /*DiagID=*/0) !=
8974             Sema::AR_inaccessible) {
8975           SemaRef.BuildBasePathArray(Paths, BasePath);
8976           return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8977         }
8978       }
8979     }
8980   }
8981   if (ReductionIdScopeSpec.isSet()) {
8982     SemaRef.Diag(Loc, diag::err_omp_not_resolved_reduction_identifier) << Range;
8983     return ExprError();
8984   }
8985   return ExprEmpty();
8986 }
8987 
ActOnOpenMPReductionClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,CXXScopeSpec & ReductionIdScopeSpec,const DeclarationNameInfo & ReductionId,ArrayRef<Expr * > UnresolvedReductions)8988 OMPClause *Sema::ActOnOpenMPReductionClause(
8989     ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
8990     SourceLocation ColonLoc, SourceLocation EndLoc,
8991     CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId,
8992     ArrayRef<Expr *> UnresolvedReductions) {
8993   auto DN = ReductionId.getName();
8994   auto OOK = DN.getCXXOverloadedOperator();
8995   BinaryOperatorKind BOK = BO_Comma;
8996 
8997   // OpenMP [2.14.3.6, reduction clause]
8998   // C
8999   // reduction-identifier is either an identifier or one of the following
9000   // operators: +, -, *,  &, |, ^, && and ||
9001   // C++
9002   // reduction-identifier is either an id-expression or one of the following
9003   // operators: +, -, *, &, |, ^, && and ||
9004   // FIXME: Only 'min' and 'max' identifiers are supported for now.
9005   switch (OOK) {
9006   case OO_Plus:
9007   case OO_Minus:
9008     BOK = BO_Add;
9009     break;
9010   case OO_Star:
9011     BOK = BO_Mul;
9012     break;
9013   case OO_Amp:
9014     BOK = BO_And;
9015     break;
9016   case OO_Pipe:
9017     BOK = BO_Or;
9018     break;
9019   case OO_Caret:
9020     BOK = BO_Xor;
9021     break;
9022   case OO_AmpAmp:
9023     BOK = BO_LAnd;
9024     break;
9025   case OO_PipePipe:
9026     BOK = BO_LOr;
9027     break;
9028   case OO_New:
9029   case OO_Delete:
9030   case OO_Array_New:
9031   case OO_Array_Delete:
9032   case OO_Slash:
9033   case OO_Percent:
9034   case OO_Tilde:
9035   case OO_Exclaim:
9036   case OO_Equal:
9037   case OO_Less:
9038   case OO_Greater:
9039   case OO_LessEqual:
9040   case OO_GreaterEqual:
9041   case OO_PlusEqual:
9042   case OO_MinusEqual:
9043   case OO_StarEqual:
9044   case OO_SlashEqual:
9045   case OO_PercentEqual:
9046   case OO_CaretEqual:
9047   case OO_AmpEqual:
9048   case OO_PipeEqual:
9049   case OO_LessLess:
9050   case OO_GreaterGreater:
9051   case OO_LessLessEqual:
9052   case OO_GreaterGreaterEqual:
9053   case OO_EqualEqual:
9054   case OO_ExclaimEqual:
9055   case OO_PlusPlus:
9056   case OO_MinusMinus:
9057   case OO_Comma:
9058   case OO_ArrowStar:
9059   case OO_Arrow:
9060   case OO_Call:
9061   case OO_Subscript:
9062   case OO_Conditional:
9063   case OO_Coawait:
9064   case NUM_OVERLOADED_OPERATORS:
9065     llvm_unreachable("Unexpected reduction identifier");
9066   case OO_None:
9067     if (auto II = DN.getAsIdentifierInfo()) {
9068       if (II->isStr("max"))
9069         BOK = BO_GT;
9070       else if (II->isStr("min"))
9071         BOK = BO_LT;
9072     }
9073     break;
9074   }
9075   SourceRange ReductionIdRange;
9076   if (ReductionIdScopeSpec.isValid())
9077     ReductionIdRange.setBegin(ReductionIdScopeSpec.getBeginLoc());
9078   ReductionIdRange.setEnd(ReductionId.getEndLoc());
9079 
9080   SmallVector<Expr *, 8> Vars;
9081   SmallVector<Expr *, 8> Privates;
9082   SmallVector<Expr *, 8> LHSs;
9083   SmallVector<Expr *, 8> RHSs;
9084   SmallVector<Expr *, 8> ReductionOps;
9085   SmallVector<Decl *, 4> ExprCaptures;
9086   SmallVector<Expr *, 4> ExprPostUpdates;
9087   auto IR = UnresolvedReductions.begin(), ER = UnresolvedReductions.end();
9088   bool FirstIter = true;
9089   for (auto RefExpr : VarList) {
9090     assert(RefExpr && "nullptr expr in OpenMP reduction clause.");
9091     // OpenMP [2.1, C/C++]
9092     //  A list item is a variable or array section, subject to the restrictions
9093     //  specified in Section 2.4 on page 42 and in each of the sections
9094     // describing clauses and directives for which a list appears.
9095     // OpenMP  [2.14.3.3, Restrictions, p.1]
9096     //  A variable that is part of another variable (as an array or
9097     //  structure element) cannot appear in a private clause.
9098     if (!FirstIter && IR != ER)
9099       ++IR;
9100     FirstIter = false;
9101     SourceLocation ELoc;
9102     SourceRange ERange;
9103     Expr *SimpleRefExpr = RefExpr;
9104     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9105                               /*AllowArraySection=*/true);
9106     if (Res.second) {
9107       // It will be analyzed later.
9108       Vars.push_back(RefExpr);
9109       Privates.push_back(nullptr);
9110       LHSs.push_back(nullptr);
9111       RHSs.push_back(nullptr);
9112       // Try to find 'declare reduction' corresponding construct before using
9113       // builtin/overloaded operators.
9114       QualType Type = Context.DependentTy;
9115       CXXCastPath BasePath;
9116       ExprResult DeclareReductionRef = buildDeclareReductionRef(
9117           *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
9118           ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
9119       if (CurContext->isDependentContext() &&
9120           (DeclareReductionRef.isUnset() ||
9121            isa<UnresolvedLookupExpr>(DeclareReductionRef.get())))
9122         ReductionOps.push_back(DeclareReductionRef.get());
9123       else
9124         ReductionOps.push_back(nullptr);
9125     }
9126     ValueDecl *D = Res.first;
9127     if (!D)
9128       continue;
9129 
9130     QualType Type;
9131     auto *ASE = dyn_cast<ArraySubscriptExpr>(RefExpr->IgnoreParens());
9132     auto *OASE = dyn_cast<OMPArraySectionExpr>(RefExpr->IgnoreParens());
9133     if (ASE)
9134       Type = ASE->getType().getNonReferenceType();
9135     else if (OASE) {
9136       auto BaseType = OMPArraySectionExpr::getBaseOriginalType(OASE->getBase());
9137       if (auto *ATy = BaseType->getAsArrayTypeUnsafe())
9138         Type = ATy->getElementType();
9139       else
9140         Type = BaseType->getPointeeType();
9141       Type = Type.getNonReferenceType();
9142     } else
9143       Type = Context.getBaseElementType(D->getType().getNonReferenceType());
9144     auto *VD = dyn_cast<VarDecl>(D);
9145 
9146     // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
9147     //  A variable that appears in a private clause must not have an incomplete
9148     //  type or a reference type.
9149     if (RequireCompleteType(ELoc, Type,
9150                             diag::err_omp_reduction_incomplete_type))
9151       continue;
9152     // OpenMP [2.14.3.6, reduction clause, Restrictions]
9153     // A list item that appears in a reduction clause must not be
9154     // const-qualified.
9155     if (Type.getNonReferenceType().isConstant(Context)) {
9156       Diag(ELoc, diag::err_omp_const_reduction_list_item)
9157           << getOpenMPClauseName(OMPC_reduction) << Type << ERange;
9158       if (!ASE && !OASE) {
9159         bool IsDecl = !VD ||
9160                       VD->isThisDeclarationADefinition(Context) ==
9161                           VarDecl::DeclarationOnly;
9162         Diag(D->getLocation(),
9163              IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9164             << D;
9165       }
9166       continue;
9167     }
9168     // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]
9169     //  If a list-item is a reference type then it must bind to the same object
9170     //  for all threads of the team.
9171     if (!ASE && !OASE && VD) {
9172       VarDecl *VDDef = VD->getDefinition();
9173       if (VD->getType()->isReferenceType() && VDDef) {
9174         DSARefChecker Check(DSAStack);
9175         if (Check.Visit(VDDef->getInit())) {
9176           Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange;
9177           Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
9178           continue;
9179         }
9180       }
9181     }
9182 
9183     // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
9184     // in a Construct]
9185     //  Variables with the predetermined data-sharing attributes may not be
9186     //  listed in data-sharing attributes clauses, except for the cases
9187     //  listed below. For these exceptions only, listing a predetermined
9188     //  variable in a data-sharing attribute clause is allowed and overrides
9189     //  the variable's predetermined data-sharing attributes.
9190     // OpenMP [2.14.3.6, Restrictions, p.3]
9191     //  Any number of reduction clauses can be specified on the directive,
9192     //  but a list item can appear only once in the reduction clauses for that
9193     //  directive.
9194     DSAStackTy::DSAVarData DVar;
9195     DVar = DSAStack->getTopDSA(D, false);
9196     if (DVar.CKind == OMPC_reduction) {
9197       Diag(ELoc, diag::err_omp_once_referenced)
9198           << getOpenMPClauseName(OMPC_reduction);
9199       if (DVar.RefExpr)
9200         Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);
9201     } else if (DVar.CKind != OMPC_unknown) {
9202       Diag(ELoc, diag::err_omp_wrong_dsa)
9203           << getOpenMPClauseName(DVar.CKind)
9204           << getOpenMPClauseName(OMPC_reduction);
9205       ReportOriginalDSA(*this, DSAStack, D, DVar);
9206       continue;
9207     }
9208 
9209     // OpenMP [2.14.3.6, Restrictions, p.1]
9210     //  A list item that appears in a reduction clause of a worksharing
9211     //  construct must be shared in the parallel regions to which any of the
9212     //  worksharing regions arising from the worksharing construct bind.
9213     OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
9214     if (isOpenMPWorksharingDirective(CurrDir) &&
9215         !isOpenMPParallelDirective(CurrDir)) {
9216       DVar = DSAStack->getImplicitDSA(D, true);
9217       if (DVar.CKind != OMPC_shared) {
9218         Diag(ELoc, diag::err_omp_required_access)
9219             << getOpenMPClauseName(OMPC_reduction)
9220             << getOpenMPClauseName(OMPC_shared);
9221         ReportOriginalDSA(*this, DSAStack, D, DVar);
9222         continue;
9223       }
9224     }
9225 
9226     // Try to find 'declare reduction' corresponding construct before using
9227     // builtin/overloaded operators.
9228     CXXCastPath BasePath;
9229     ExprResult DeclareReductionRef = buildDeclareReductionRef(
9230         *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
9231         ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
9232     if (DeclareReductionRef.isInvalid())
9233       continue;
9234     if (CurContext->isDependentContext() &&
9235         (DeclareReductionRef.isUnset() ||
9236          isa<UnresolvedLookupExpr>(DeclareReductionRef.get()))) {
9237       Vars.push_back(RefExpr);
9238       Privates.push_back(nullptr);
9239       LHSs.push_back(nullptr);
9240       RHSs.push_back(nullptr);
9241       ReductionOps.push_back(DeclareReductionRef.get());
9242       continue;
9243     }
9244     if (BOK == BO_Comma && DeclareReductionRef.isUnset()) {
9245       // Not allowed reduction identifier is found.
9246       Diag(ReductionId.getLocStart(),
9247            diag::err_omp_unknown_reduction_identifier)
9248           << Type << ReductionIdRange;
9249       continue;
9250     }
9251 
9252     // OpenMP [2.14.3.6, reduction clause, Restrictions]
9253     // The type of a list item that appears in a reduction clause must be valid
9254     // for the reduction-identifier. For a max or min reduction in C, the type
9255     // of the list item must be an allowed arithmetic data type: char, int,
9256     // float, double, or _Bool, possibly modified with long, short, signed, or
9257     // unsigned. For a max or min reduction in C++, the type of the list item
9258     // must be an allowed arithmetic data type: char, wchar_t, int, float,
9259     // double, or bool, possibly modified with long, short, signed, or unsigned.
9260     if (DeclareReductionRef.isUnset()) {
9261       if ((BOK == BO_GT || BOK == BO_LT) &&
9262           !(Type->isScalarType() ||
9263             (getLangOpts().CPlusPlus && Type->isArithmeticType()))) {
9264         Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg)
9265             << getLangOpts().CPlusPlus;
9266         if (!ASE && !OASE) {
9267           bool IsDecl = !VD ||
9268                         VD->isThisDeclarationADefinition(Context) ==
9269                             VarDecl::DeclarationOnly;
9270           Diag(D->getLocation(),
9271                IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9272               << D;
9273         }
9274         continue;
9275       }
9276       if ((BOK == BO_OrAssign || BOK == BO_AndAssign || BOK == BO_XorAssign) &&
9277           !getLangOpts().CPlusPlus && Type->isFloatingType()) {
9278         Diag(ELoc, diag::err_omp_clause_floating_type_arg);
9279         if (!ASE && !OASE) {
9280           bool IsDecl = !VD ||
9281                         VD->isThisDeclarationADefinition(Context) ==
9282                             VarDecl::DeclarationOnly;
9283           Diag(D->getLocation(),
9284                IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9285               << D;
9286         }
9287         continue;
9288       }
9289     }
9290 
9291     Type = Type.getNonLValueExprType(Context).getUnqualifiedType();
9292     auto *LHSVD = buildVarDecl(*this, ELoc, Type, ".reduction.lhs",
9293                                D->hasAttrs() ? &D->getAttrs() : nullptr);
9294     auto *RHSVD = buildVarDecl(*this, ELoc, Type, D->getName(),
9295                                D->hasAttrs() ? &D->getAttrs() : nullptr);
9296     auto PrivateTy = Type;
9297     if (OASE ||
9298         (!ASE &&
9299          D->getType().getNonReferenceType()->isVariablyModifiedType())) {
9300       // For arays/array sections only:
9301       // Create pseudo array type for private copy. The size for this array will
9302       // be generated during codegen.
9303       // For array subscripts or single variables Private Ty is the same as Type
9304       // (type of the variable or single array element).
9305       PrivateTy = Context.getVariableArrayType(
9306           Type, new (Context) OpaqueValueExpr(SourceLocation(),
9307                                               Context.getSizeType(), VK_RValue),
9308           ArrayType::Normal, /*IndexTypeQuals=*/0, SourceRange());
9309     } else if (!ASE && !OASE &&
9310                Context.getAsArrayType(D->getType().getNonReferenceType()))
9311       PrivateTy = D->getType().getNonReferenceType();
9312     // Private copy.
9313     auto *PrivateVD = buildVarDecl(*this, ELoc, PrivateTy, D->getName(),
9314                                    D->hasAttrs() ? &D->getAttrs() : nullptr);
9315     // Add initializer for private variable.
9316     Expr *Init = nullptr;
9317     auto *LHSDRE = buildDeclRefExpr(*this, LHSVD, Type, ELoc);
9318     auto *RHSDRE = buildDeclRefExpr(*this, RHSVD, Type, ELoc);
9319     if (DeclareReductionRef.isUsable()) {
9320       auto *DRDRef = DeclareReductionRef.getAs<DeclRefExpr>();
9321       auto *DRD = cast<OMPDeclareReductionDecl>(DRDRef->getDecl());
9322       if (DRD->getInitializer()) {
9323         Init = DRDRef;
9324         RHSVD->setInit(DRDRef);
9325         RHSVD->setInitStyle(VarDecl::CallInit);
9326       }
9327     } else {
9328       switch (BOK) {
9329       case BO_Add:
9330       case BO_Xor:
9331       case BO_Or:
9332       case BO_LOr:
9333         // '+', '-', '^', '|', '||' reduction ops - initializer is '0'.
9334         if (Type->isScalarType() || Type->isAnyComplexType())
9335           Init = ActOnIntegerConstant(ELoc, /*Val=*/0).get();
9336         break;
9337       case BO_Mul:
9338       case BO_LAnd:
9339         if (Type->isScalarType() || Type->isAnyComplexType()) {
9340           // '*' and '&&' reduction ops - initializer is '1'.
9341           Init = ActOnIntegerConstant(ELoc, /*Val=*/1).get();
9342         }
9343         break;
9344       case BO_And: {
9345         // '&' reduction op - initializer is '~0'.
9346         QualType OrigType = Type;
9347         if (auto *ComplexTy = OrigType->getAs<ComplexType>())
9348           Type = ComplexTy->getElementType();
9349         if (Type->isRealFloatingType()) {
9350           llvm::APFloat InitValue =
9351               llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type),
9352                                              /*isIEEE=*/true);
9353           Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
9354                                          Type, ELoc);
9355         } else if (Type->isScalarType()) {
9356           auto Size = Context.getTypeSize(Type);
9357           QualType IntTy = Context.getIntTypeForBitwidth(Size, /*Signed=*/0);
9358           llvm::APInt InitValue = llvm::APInt::getAllOnesValue(Size);
9359           Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
9360         }
9361         if (Init && OrigType->isAnyComplexType()) {
9362           // Init = 0xFFFF + 0xFFFFi;
9363           auto *Im = new (Context) ImaginaryLiteral(Init, OrigType);
9364           Init = CreateBuiltinBinOp(ELoc, BO_Add, Init, Im).get();
9365         }
9366         Type = OrigType;
9367         break;
9368       }
9369       case BO_LT:
9370       case BO_GT: {
9371         // 'min' reduction op - initializer is 'Largest representable number in
9372         // the reduction list item type'.
9373         // 'max' reduction op - initializer is 'Least representable number in
9374         // the reduction list item type'.
9375         if (Type->isIntegerType() || Type->isPointerType()) {
9376           bool IsSigned = Type->hasSignedIntegerRepresentation();
9377           auto Size = Context.getTypeSize(Type);
9378           QualType IntTy =
9379               Context.getIntTypeForBitwidth(Size, /*Signed=*/IsSigned);
9380           llvm::APInt InitValue =
9381               (BOK != BO_LT)
9382                   ? IsSigned ? llvm::APInt::getSignedMinValue(Size)
9383                              : llvm::APInt::getMinValue(Size)
9384                   : IsSigned ? llvm::APInt::getSignedMaxValue(Size)
9385                              : llvm::APInt::getMaxValue(Size);
9386           Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
9387           if (Type->isPointerType()) {
9388             // Cast to pointer type.
9389             auto CastExpr = BuildCStyleCastExpr(
9390                 SourceLocation(), Context.getTrivialTypeSourceInfo(Type, ELoc),
9391                 SourceLocation(), Init);
9392             if (CastExpr.isInvalid())
9393               continue;
9394             Init = CastExpr.get();
9395           }
9396         } else if (Type->isRealFloatingType()) {
9397           llvm::APFloat InitValue = llvm::APFloat::getLargest(
9398               Context.getFloatTypeSemantics(Type), BOK != BO_LT);
9399           Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
9400                                          Type, ELoc);
9401         }
9402         break;
9403       }
9404       case BO_PtrMemD:
9405       case BO_PtrMemI:
9406       case BO_MulAssign:
9407       case BO_Div:
9408       case BO_Rem:
9409       case BO_Sub:
9410       case BO_Shl:
9411       case BO_Shr:
9412       case BO_LE:
9413       case BO_GE:
9414       case BO_EQ:
9415       case BO_NE:
9416       case BO_AndAssign:
9417       case BO_XorAssign:
9418       case BO_OrAssign:
9419       case BO_Assign:
9420       case BO_AddAssign:
9421       case BO_SubAssign:
9422       case BO_DivAssign:
9423       case BO_RemAssign:
9424       case BO_ShlAssign:
9425       case BO_ShrAssign:
9426       case BO_Comma:
9427         llvm_unreachable("Unexpected reduction operation");
9428       }
9429     }
9430     if (Init && DeclareReductionRef.isUnset()) {
9431       AddInitializerToDecl(RHSVD, Init, /*DirectInit=*/false,
9432                            /*TypeMayContainAuto=*/false);
9433     } else if (!Init)
9434       ActOnUninitializedDecl(RHSVD, /*TypeMayContainAuto=*/false);
9435     if (RHSVD->isInvalidDecl())
9436       continue;
9437     if (!RHSVD->hasInit() && DeclareReductionRef.isUnset()) {
9438       Diag(ELoc, diag::err_omp_reduction_id_not_compatible) << Type
9439                                                             << ReductionIdRange;
9440       bool IsDecl =
9441           !VD ||
9442           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9443       Diag(D->getLocation(),
9444            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9445           << D;
9446       continue;
9447     }
9448     // Store initializer for single element in private copy. Will be used during
9449     // codegen.
9450     PrivateVD->setInit(RHSVD->getInit());
9451     PrivateVD->setInitStyle(RHSVD->getInitStyle());
9452     auto *PrivateDRE = buildDeclRefExpr(*this, PrivateVD, PrivateTy, ELoc);
9453     ExprResult ReductionOp;
9454     if (DeclareReductionRef.isUsable()) {
9455       QualType RedTy = DeclareReductionRef.get()->getType();
9456       QualType PtrRedTy = Context.getPointerType(RedTy);
9457       ExprResult LHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, LHSDRE);
9458       ExprResult RHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, RHSDRE);
9459       if (!BasePath.empty()) {
9460         LHS = DefaultLvalueConversion(LHS.get());
9461         RHS = DefaultLvalueConversion(RHS.get());
9462         LHS = ImplicitCastExpr::Create(Context, PtrRedTy,
9463                                        CK_UncheckedDerivedToBase, LHS.get(),
9464                                        &BasePath, LHS.get()->getValueKind());
9465         RHS = ImplicitCastExpr::Create(Context, PtrRedTy,
9466                                        CK_UncheckedDerivedToBase, RHS.get(),
9467                                        &BasePath, RHS.get()->getValueKind());
9468       }
9469       FunctionProtoType::ExtProtoInfo EPI;
9470       QualType Params[] = {PtrRedTy, PtrRedTy};
9471       QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
9472       auto *OVE = new (Context) OpaqueValueExpr(
9473           ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
9474           DefaultLvalueConversion(DeclareReductionRef.get()).get());
9475       Expr *Args[] = {LHS.get(), RHS.get()};
9476       ReductionOp = new (Context)
9477           CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
9478     } else {
9479       ReductionOp = BuildBinOp(DSAStack->getCurScope(),
9480                                ReductionId.getLocStart(), BOK, LHSDRE, RHSDRE);
9481       if (ReductionOp.isUsable()) {
9482         if (BOK != BO_LT && BOK != BO_GT) {
9483           ReductionOp =
9484               BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
9485                          BO_Assign, LHSDRE, ReductionOp.get());
9486         } else {
9487           auto *ConditionalOp = new (Context) ConditionalOperator(
9488               ReductionOp.get(), SourceLocation(), LHSDRE, SourceLocation(),
9489               RHSDRE, Type, VK_LValue, OK_Ordinary);
9490           ReductionOp =
9491               BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
9492                          BO_Assign, LHSDRE, ConditionalOp);
9493         }
9494         ReductionOp = ActOnFinishFullExpr(ReductionOp.get());
9495       }
9496       if (ReductionOp.isInvalid())
9497         continue;
9498     }
9499 
9500     DeclRefExpr *Ref = nullptr;
9501     Expr *VarsExpr = RefExpr->IgnoreParens();
9502     if (!VD && !CurContext->isDependentContext()) {
9503       if (ASE || OASE) {
9504         TransformExprToCaptures RebuildToCapture(*this, D);
9505         VarsExpr =
9506             RebuildToCapture.TransformExpr(RefExpr->IgnoreParens()).get();
9507         Ref = RebuildToCapture.getCapturedExpr();
9508       } else {
9509         VarsExpr = Ref =
9510             buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
9511       }
9512       if (!IsOpenMPCapturedDecl(D)) {
9513         ExprCaptures.push_back(Ref->getDecl());
9514         if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
9515           ExprResult RefRes = DefaultLvalueConversion(Ref);
9516           if (!RefRes.isUsable())
9517             continue;
9518           ExprResult PostUpdateRes =
9519               BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9520                          SimpleRefExpr, RefRes.get());
9521           if (!PostUpdateRes.isUsable())
9522             continue;
9523           ExprPostUpdates.push_back(
9524               IgnoredValueConversions(PostUpdateRes.get()).get());
9525         }
9526       }
9527     }
9528     DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_reduction, Ref);
9529     Vars.push_back(VarsExpr);
9530     Privates.push_back(PrivateDRE);
9531     LHSs.push_back(LHSDRE);
9532     RHSs.push_back(RHSDRE);
9533     ReductionOps.push_back(ReductionOp.get());
9534   }
9535 
9536   if (Vars.empty())
9537     return nullptr;
9538 
9539   return OMPReductionClause::Create(
9540       Context, StartLoc, LParenLoc, ColonLoc, EndLoc, Vars,
9541       ReductionIdScopeSpec.getWithLocInContext(Context), ReductionId, Privates,
9542       LHSs, RHSs, ReductionOps, buildPreInits(Context, ExprCaptures),
9543       buildPostUpdate(*this, ExprPostUpdates));
9544 }
9545 
CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,SourceLocation LinLoc)9546 bool Sema::CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
9547                                      SourceLocation LinLoc) {
9548   if ((!LangOpts.CPlusPlus && LinKind != OMPC_LINEAR_val) ||
9549       LinKind == OMPC_LINEAR_unknown) {
9550     Diag(LinLoc, diag::err_omp_wrong_linear_modifier) << LangOpts.CPlusPlus;
9551     return true;
9552   }
9553   return false;
9554 }
9555 
CheckOpenMPLinearDecl(ValueDecl * D,SourceLocation ELoc,OpenMPLinearClauseKind LinKind,QualType Type)9556 bool Sema::CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc,
9557                                  OpenMPLinearClauseKind LinKind,
9558                                  QualType Type) {
9559   auto *VD = dyn_cast_or_null<VarDecl>(D);
9560   // A variable must not have an incomplete type or a reference type.
9561   if (RequireCompleteType(ELoc, Type, diag::err_omp_linear_incomplete_type))
9562     return true;
9563   if ((LinKind == OMPC_LINEAR_uval || LinKind == OMPC_LINEAR_ref) &&
9564       !Type->isReferenceType()) {
9565     Diag(ELoc, diag::err_omp_wrong_linear_modifier_non_reference)
9566         << Type << getOpenMPSimpleClauseTypeName(OMPC_linear, LinKind);
9567     return true;
9568   }
9569   Type = Type.getNonReferenceType();
9570 
9571   // A list item must not be const-qualified.
9572   if (Type.isConstant(Context)) {
9573     Diag(ELoc, diag::err_omp_const_variable)
9574         << getOpenMPClauseName(OMPC_linear);
9575     if (D) {
9576       bool IsDecl =
9577           !VD ||
9578           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9579       Diag(D->getLocation(),
9580            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9581           << D;
9582     }
9583     return true;
9584   }
9585 
9586   // A list item must be of integral or pointer type.
9587   Type = Type.getUnqualifiedType().getCanonicalType();
9588   const auto *Ty = Type.getTypePtrOrNull();
9589   if (!Ty || (!Ty->isDependentType() && !Ty->isIntegralType(Context) &&
9590               !Ty->isPointerType())) {
9591     Diag(ELoc, diag::err_omp_linear_expected_int_or_ptr) << Type;
9592     if (D) {
9593       bool IsDecl =
9594           !VD ||
9595           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9596       Diag(D->getLocation(),
9597            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9598           << D;
9599     }
9600     return true;
9601   }
9602   return false;
9603 }
9604 
ActOnOpenMPLinearClause(ArrayRef<Expr * > VarList,Expr * Step,SourceLocation StartLoc,SourceLocation LParenLoc,OpenMPLinearClauseKind LinKind,SourceLocation LinLoc,SourceLocation ColonLoc,SourceLocation EndLoc)9605 OMPClause *Sema::ActOnOpenMPLinearClause(
9606     ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
9607     SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind,
9608     SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9609   SmallVector<Expr *, 8> Vars;
9610   SmallVector<Expr *, 8> Privates;
9611   SmallVector<Expr *, 8> Inits;
9612   SmallVector<Decl *, 4> ExprCaptures;
9613   SmallVector<Expr *, 4> ExprPostUpdates;
9614   if (CheckOpenMPLinearModifier(LinKind, LinLoc))
9615     LinKind = OMPC_LINEAR_val;
9616   for (auto &RefExpr : VarList) {
9617     assert(RefExpr && "NULL expr in OpenMP linear clause.");
9618     SourceLocation ELoc;
9619     SourceRange ERange;
9620     Expr *SimpleRefExpr = RefExpr;
9621     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9622                               /*AllowArraySection=*/false);
9623     if (Res.second) {
9624       // It will be analyzed later.
9625       Vars.push_back(RefExpr);
9626       Privates.push_back(nullptr);
9627       Inits.push_back(nullptr);
9628     }
9629     ValueDecl *D = Res.first;
9630     if (!D)
9631       continue;
9632 
9633     QualType Type = D->getType();
9634     auto *VD = dyn_cast<VarDecl>(D);
9635 
9636     // OpenMP [2.14.3.7, linear clause]
9637     //  A list-item cannot appear in more than one linear clause.
9638     //  A list-item that appears in a linear clause cannot appear in any
9639     //  other data-sharing attribute clause.
9640     DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
9641     if (DVar.RefExpr) {
9642       Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
9643                                           << getOpenMPClauseName(OMPC_linear);
9644       ReportOriginalDSA(*this, DSAStack, D, DVar);
9645       continue;
9646     }
9647 
9648     if (CheckOpenMPLinearDecl(D, ELoc, LinKind, Type))
9649       continue;
9650     Type = Type.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9651 
9652     // Build private copy of original var.
9653     auto *Private = buildVarDecl(*this, ELoc, Type, D->getName(),
9654                                  D->hasAttrs() ? &D->getAttrs() : nullptr);
9655     auto *PrivateRef = buildDeclRefExpr(*this, Private, Type, ELoc);
9656     // Build var to save initial value.
9657     VarDecl *Init = buildVarDecl(*this, ELoc, Type, ".linear.start");
9658     Expr *InitExpr;
9659     DeclRefExpr *Ref = nullptr;
9660     if (!VD && !CurContext->isDependentContext()) {
9661       Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
9662       if (!IsOpenMPCapturedDecl(D)) {
9663         ExprCaptures.push_back(Ref->getDecl());
9664         if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
9665           ExprResult RefRes = DefaultLvalueConversion(Ref);
9666           if (!RefRes.isUsable())
9667             continue;
9668           ExprResult PostUpdateRes =
9669               BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9670                          SimpleRefExpr, RefRes.get());
9671           if (!PostUpdateRes.isUsable())
9672             continue;
9673           ExprPostUpdates.push_back(
9674               IgnoredValueConversions(PostUpdateRes.get()).get());
9675         }
9676       }
9677     }
9678     if (LinKind == OMPC_LINEAR_uval)
9679       InitExpr = VD ? VD->getInit() : SimpleRefExpr;
9680     else
9681       InitExpr = VD ? SimpleRefExpr : Ref;
9682     AddInitializerToDecl(Init, DefaultLvalueConversion(InitExpr).get(),
9683                          /*DirectInit=*/false, /*TypeMayContainAuto=*/false);
9684     auto InitRef = buildDeclRefExpr(*this, Init, Type, ELoc);
9685 
9686     DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_linear, Ref);
9687     Vars.push_back((VD || CurContext->isDependentContext())
9688                        ? RefExpr->IgnoreParens()
9689                        : Ref);
9690     Privates.push_back(PrivateRef);
9691     Inits.push_back(InitRef);
9692   }
9693 
9694   if (Vars.empty())
9695     return nullptr;
9696 
9697   Expr *StepExpr = Step;
9698   Expr *CalcStepExpr = nullptr;
9699   if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
9700       !Step->isInstantiationDependent() &&
9701       !Step->containsUnexpandedParameterPack()) {
9702     SourceLocation StepLoc = Step->getLocStart();
9703     ExprResult Val = PerformOpenMPImplicitIntegerConversion(StepLoc, Step);
9704     if (Val.isInvalid())
9705       return nullptr;
9706     StepExpr = Val.get();
9707 
9708     // Build var to save the step value.
9709     VarDecl *SaveVar =
9710         buildVarDecl(*this, StepLoc, StepExpr->getType(), ".linear.step");
9711     ExprResult SaveRef =
9712         buildDeclRefExpr(*this, SaveVar, StepExpr->getType(), StepLoc);
9713     ExprResult CalcStep =
9714         BuildBinOp(CurScope, StepLoc, BO_Assign, SaveRef.get(), StepExpr);
9715     CalcStep = ActOnFinishFullExpr(CalcStep.get());
9716 
9717     // Warn about zero linear step (it would be probably better specified as
9718     // making corresponding variables 'const').
9719     llvm::APSInt Result;
9720     bool IsConstant = StepExpr->isIntegerConstantExpr(Result, Context);
9721     if (IsConstant && !Result.isNegative() && !Result.isStrictlyPositive())
9722       Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0]
9723                                                      << (Vars.size() > 1);
9724     if (!IsConstant && CalcStep.isUsable()) {
9725       // Calculate the step beforehand instead of doing this on each iteration.
9726       // (This is not used if the number of iterations may be kfold-ed).
9727       CalcStepExpr = CalcStep.get();
9728     }
9729   }
9730 
9731   return OMPLinearClause::Create(Context, StartLoc, LParenLoc, LinKind, LinLoc,
9732                                  ColonLoc, EndLoc, Vars, Privates, Inits,
9733                                  StepExpr, CalcStepExpr,
9734                                  buildPreInits(Context, ExprCaptures),
9735                                  buildPostUpdate(*this, ExprPostUpdates));
9736 }
9737 
FinishOpenMPLinearClause(OMPLinearClause & Clause,DeclRefExpr * IV,Expr * NumIterations,Sema & SemaRef,Scope * S,DSAStackTy * Stack)9738 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
9739                                      Expr *NumIterations, Sema &SemaRef,
9740                                      Scope *S, DSAStackTy *Stack) {
9741   // Walk the vars and build update/final expressions for the CodeGen.
9742   SmallVector<Expr *, 8> Updates;
9743   SmallVector<Expr *, 8> Finals;
9744   Expr *Step = Clause.getStep();
9745   Expr *CalcStep = Clause.getCalcStep();
9746   // OpenMP [2.14.3.7, linear clause]
9747   // If linear-step is not specified it is assumed to be 1.
9748   if (Step == nullptr)
9749     Step = SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get();
9750   else if (CalcStep) {
9751     Step = cast<BinaryOperator>(CalcStep)->getLHS();
9752   }
9753   bool HasErrors = false;
9754   auto CurInit = Clause.inits().begin();
9755   auto CurPrivate = Clause.privates().begin();
9756   auto LinKind = Clause.getModifier();
9757   for (auto &RefExpr : Clause.varlists()) {
9758     SourceLocation ELoc;
9759     SourceRange ERange;
9760     Expr *SimpleRefExpr = RefExpr;
9761     auto Res = getPrivateItem(SemaRef, SimpleRefExpr, ELoc, ERange,
9762                               /*AllowArraySection=*/false);
9763     ValueDecl *D = Res.first;
9764     if (Res.second || !D) {
9765       Updates.push_back(nullptr);
9766       Finals.push_back(nullptr);
9767       HasErrors = true;
9768       continue;
9769     }
9770     if (auto *CED = dyn_cast<OMPCapturedExprDecl>(D)) {
9771       D = cast<MemberExpr>(CED->getInit()->IgnoreParenImpCasts())
9772               ->getMemberDecl();
9773     }
9774     auto &&Info = Stack->isLoopControlVariable(D);
9775     Expr *InitExpr = *CurInit;
9776 
9777     // Build privatized reference to the current linear var.
9778     auto DE = cast<DeclRefExpr>(SimpleRefExpr);
9779     Expr *CapturedRef;
9780     if (LinKind == OMPC_LINEAR_uval)
9781       CapturedRef = cast<VarDecl>(DE->getDecl())->getInit();
9782     else
9783       CapturedRef =
9784           buildDeclRefExpr(SemaRef, cast<VarDecl>(DE->getDecl()),
9785                            DE->getType().getUnqualifiedType(), DE->getExprLoc(),
9786                            /*RefersToCapture=*/true);
9787 
9788     // Build update: Var = InitExpr + IV * Step
9789     ExprResult Update;
9790     if (!Info.first) {
9791       Update =
9792           BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), *CurPrivate,
9793                              InitExpr, IV, Step, /* Subtract */ false);
9794     } else
9795       Update = *CurPrivate;
9796     Update = SemaRef.ActOnFinishFullExpr(Update.get(), DE->getLocStart(),
9797                                          /*DiscardedValue=*/true);
9798 
9799     // Build final: Var = InitExpr + NumIterations * Step
9800     ExprResult Final;
9801     if (!Info.first) {
9802       Final = BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), CapturedRef,
9803                                  InitExpr, NumIterations, Step,
9804                                  /* Subtract */ false);
9805     } else
9806       Final = *CurPrivate;
9807     Final = SemaRef.ActOnFinishFullExpr(Final.get(), DE->getLocStart(),
9808                                         /*DiscardedValue=*/true);
9809 
9810     if (!Update.isUsable() || !Final.isUsable()) {
9811       Updates.push_back(nullptr);
9812       Finals.push_back(nullptr);
9813       HasErrors = true;
9814     } else {
9815       Updates.push_back(Update.get());
9816       Finals.push_back(Final.get());
9817     }
9818     ++CurInit;
9819     ++CurPrivate;
9820   }
9821   Clause.setUpdates(Updates);
9822   Clause.setFinals(Finals);
9823   return HasErrors;
9824 }
9825 
ActOnOpenMPAlignedClause(ArrayRef<Expr * > VarList,Expr * Alignment,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc)9826 OMPClause *Sema::ActOnOpenMPAlignedClause(
9827     ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
9828     SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9829 
9830   SmallVector<Expr *, 8> Vars;
9831   for (auto &RefExpr : VarList) {
9832     assert(RefExpr && "NULL expr in OpenMP linear clause.");
9833     SourceLocation ELoc;
9834     SourceRange ERange;
9835     Expr *SimpleRefExpr = RefExpr;
9836     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9837                               /*AllowArraySection=*/false);
9838     if (Res.second) {
9839       // It will be analyzed later.
9840       Vars.push_back(RefExpr);
9841     }
9842     ValueDecl *D = Res.first;
9843     if (!D)
9844       continue;
9845 
9846     QualType QType = D->getType();
9847     auto *VD = dyn_cast<VarDecl>(D);
9848 
9849     // OpenMP  [2.8.1, simd construct, Restrictions]
9850     // The type of list items appearing in the aligned clause must be
9851     // array, pointer, reference to array, or reference to pointer.
9852     QType = QType.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9853     const Type *Ty = QType.getTypePtrOrNull();
9854     if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
9855       Diag(ELoc, diag::err_omp_aligned_expected_array_or_ptr)
9856           << QType << getLangOpts().CPlusPlus << ERange;
9857       bool IsDecl =
9858           !VD ||
9859           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9860       Diag(D->getLocation(),
9861            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9862           << D;
9863       continue;
9864     }
9865 
9866     // OpenMP  [2.8.1, simd construct, Restrictions]
9867     // A list-item cannot appear in more than one aligned clause.
9868     if (Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) {
9869       Diag(ELoc, diag::err_omp_aligned_twice) << 0 << ERange;
9870       Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa)
9871           << getOpenMPClauseName(OMPC_aligned);
9872       continue;
9873     }
9874 
9875     DeclRefExpr *Ref = nullptr;
9876     if (!VD && IsOpenMPCapturedDecl(D))
9877       Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
9878     Vars.push_back(DefaultFunctionArrayConversion(
9879                        (VD || !Ref) ? RefExpr->IgnoreParens() : Ref)
9880                        .get());
9881   }
9882 
9883   // OpenMP [2.8.1, simd construct, Description]
9884   // The parameter of the aligned clause, alignment, must be a constant
9885   // positive integer expression.
9886   // If no optional parameter is specified, implementation-defined default
9887   // alignments for SIMD instructions on the target platforms are assumed.
9888   if (Alignment != nullptr) {
9889     ExprResult AlignResult =
9890         VerifyPositiveIntegerConstantInClause(Alignment, OMPC_aligned);
9891     if (AlignResult.isInvalid())
9892       return nullptr;
9893     Alignment = AlignResult.get();
9894   }
9895   if (Vars.empty())
9896     return nullptr;
9897 
9898   return OMPAlignedClause::Create(Context, StartLoc, LParenLoc, ColonLoc,
9899                                   EndLoc, Vars, Alignment);
9900 }
9901 
ActOnOpenMPCopyinClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)9902 OMPClause *Sema::ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
9903                                          SourceLocation StartLoc,
9904                                          SourceLocation LParenLoc,
9905                                          SourceLocation EndLoc) {
9906   SmallVector<Expr *, 8> Vars;
9907   SmallVector<Expr *, 8> SrcExprs;
9908   SmallVector<Expr *, 8> DstExprs;
9909   SmallVector<Expr *, 8> AssignmentOps;
9910   for (auto &RefExpr : VarList) {
9911     assert(RefExpr && "NULL expr in OpenMP copyin clause.");
9912     if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
9913       // It will be analyzed later.
9914       Vars.push_back(RefExpr);
9915       SrcExprs.push_back(nullptr);
9916       DstExprs.push_back(nullptr);
9917       AssignmentOps.push_back(nullptr);
9918       continue;
9919     }
9920 
9921     SourceLocation ELoc = RefExpr->getExprLoc();
9922     // OpenMP [2.1, C/C++]
9923     //  A list item is a variable name.
9924     // OpenMP  [2.14.4.1, Restrictions, p.1]
9925     //  A list item that appears in a copyin clause must be threadprivate.
9926     DeclRefExpr *DE = dyn_cast<DeclRefExpr>(RefExpr);
9927     if (!DE || !isa<VarDecl>(DE->getDecl())) {
9928       Diag(ELoc, diag::err_omp_expected_var_name_member_expr)
9929           << 0 << RefExpr->getSourceRange();
9930       continue;
9931     }
9932 
9933     Decl *D = DE->getDecl();
9934     VarDecl *VD = cast<VarDecl>(D);
9935 
9936     QualType Type = VD->getType();
9937     if (Type->isDependentType() || Type->isInstantiationDependentType()) {
9938       // It will be analyzed later.
9939       Vars.push_back(DE);
9940       SrcExprs.push_back(nullptr);
9941       DstExprs.push_back(nullptr);
9942       AssignmentOps.push_back(nullptr);
9943       continue;
9944     }
9945 
9946     // OpenMP [2.14.4.1, Restrictions, C/C++, p.1]
9947     //  A list item that appears in a copyin clause must be threadprivate.
9948     if (!DSAStack->isThreadPrivate(VD)) {
9949       Diag(ELoc, diag::err_omp_required_access)
9950           << getOpenMPClauseName(OMPC_copyin)
9951           << getOpenMPDirectiveName(OMPD_threadprivate);
9952       continue;
9953     }
9954 
9955     // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
9956     //  A variable of class type (or array thereof) that appears in a
9957     //  copyin clause requires an accessible, unambiguous copy assignment
9958     //  operator for the class type.
9959     auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
9960     auto *SrcVD =
9961         buildVarDecl(*this, DE->getLocStart(), ElemType.getUnqualifiedType(),
9962                      ".copyin.src", VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9963     auto *PseudoSrcExpr = buildDeclRefExpr(
9964         *this, SrcVD, ElemType.getUnqualifiedType(), DE->getExprLoc());
9965     auto *DstVD =
9966         buildVarDecl(*this, DE->getLocStart(), ElemType, ".copyin.dst",
9967                      VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9968     auto *PseudoDstExpr =
9969         buildDeclRefExpr(*this, DstVD, ElemType, DE->getExprLoc());
9970     // For arrays generate assignment operation for single element and replace
9971     // it by the original array element in CodeGen.
9972     auto AssignmentOp = BuildBinOp(/*S=*/nullptr, DE->getExprLoc(), BO_Assign,
9973                                    PseudoDstExpr, PseudoSrcExpr);
9974     if (AssignmentOp.isInvalid())
9975       continue;
9976     AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), DE->getExprLoc(),
9977                                        /*DiscardedValue=*/true);
9978     if (AssignmentOp.isInvalid())
9979       continue;
9980 
9981     DSAStack->addDSA(VD, DE, OMPC_copyin);
9982     Vars.push_back(DE);
9983     SrcExprs.push_back(PseudoSrcExpr);
9984     DstExprs.push_back(PseudoDstExpr);
9985     AssignmentOps.push_back(AssignmentOp.get());
9986   }
9987 
9988   if (Vars.empty())
9989     return nullptr;
9990 
9991   return OMPCopyinClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
9992                                  SrcExprs, DstExprs, AssignmentOps);
9993 }
9994 
ActOnOpenMPCopyprivateClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)9995 OMPClause *Sema::ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
9996                                               SourceLocation StartLoc,
9997                                               SourceLocation LParenLoc,
9998                                               SourceLocation EndLoc) {
9999   SmallVector<Expr *, 8> Vars;
10000   SmallVector<Expr *, 8> SrcExprs;
10001   SmallVector<Expr *, 8> DstExprs;
10002   SmallVector<Expr *, 8> AssignmentOps;
10003   for (auto &RefExpr : VarList) {
10004     assert(RefExpr && "NULL expr in OpenMP linear clause.");
10005     SourceLocation ELoc;
10006     SourceRange ERange;
10007     Expr *SimpleRefExpr = RefExpr;
10008     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
10009                               /*AllowArraySection=*/false);
10010     if (Res.second) {
10011       // It will be analyzed later.
10012       Vars.push_back(RefExpr);
10013       SrcExprs.push_back(nullptr);
10014       DstExprs.push_back(nullptr);
10015       AssignmentOps.push_back(nullptr);
10016     }
10017     ValueDecl *D = Res.first;
10018     if (!D)
10019       continue;
10020 
10021     QualType Type = D->getType();
10022     auto *VD = dyn_cast<VarDecl>(D);
10023 
10024     // OpenMP [2.14.4.2, Restrictions, p.2]
10025     //  A list item that appears in a copyprivate clause may not appear in a
10026     //  private or firstprivate clause on the single construct.
10027     if (!VD || !DSAStack->isThreadPrivate(VD)) {
10028       auto DVar = DSAStack->getTopDSA(D, false);
10029       if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_copyprivate &&
10030           DVar.RefExpr) {
10031         Diag(ELoc, diag::err_omp_wrong_dsa)
10032             << getOpenMPClauseName(DVar.CKind)
10033             << getOpenMPClauseName(OMPC_copyprivate);
10034         ReportOriginalDSA(*this, DSAStack, D, DVar);
10035         continue;
10036       }
10037 
10038       // OpenMP [2.11.4.2, Restrictions, p.1]
10039       //  All list items that appear in a copyprivate clause must be either
10040       //  threadprivate or private in the enclosing context.
10041       if (DVar.CKind == OMPC_unknown) {
10042         DVar = DSAStack->getImplicitDSA(D, false);
10043         if (DVar.CKind == OMPC_shared) {
10044           Diag(ELoc, diag::err_omp_required_access)
10045               << getOpenMPClauseName(OMPC_copyprivate)
10046               << "threadprivate or private in the enclosing context";
10047           ReportOriginalDSA(*this, DSAStack, D, DVar);
10048           continue;
10049         }
10050       }
10051     }
10052 
10053     // Variably modified types are not supported.
10054     if (!Type->isAnyPointerType() && Type->isVariablyModifiedType()) {
10055       Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
10056           << getOpenMPClauseName(OMPC_copyprivate) << Type
10057           << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
10058       bool IsDecl =
10059           !VD ||
10060           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
10061       Diag(D->getLocation(),
10062            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
10063           << D;
10064       continue;
10065     }
10066 
10067     // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
10068     //  A variable of class type (or array thereof) that appears in a
10069     //  copyin clause requires an accessible, unambiguous copy assignment
10070     //  operator for the class type.
10071     Type = Context.getBaseElementType(Type.getNonReferenceType())
10072                .getUnqualifiedType();
10073     auto *SrcVD =
10074         buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.src",
10075                      D->hasAttrs() ? &D->getAttrs() : nullptr);
10076     auto *PseudoSrcExpr = buildDeclRefExpr(*this, SrcVD, Type, ELoc);
10077     auto *DstVD =
10078         buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.dst",
10079                      D->hasAttrs() ? &D->getAttrs() : nullptr);
10080     auto *PseudoDstExpr =
10081         buildDeclRefExpr(*this, DstVD, Type, ELoc);
10082     auto AssignmentOp = BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
10083                                    PseudoDstExpr, PseudoSrcExpr);
10084     if (AssignmentOp.isInvalid())
10085       continue;
10086     AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
10087                                        /*DiscardedValue=*/true);
10088     if (AssignmentOp.isInvalid())
10089       continue;
10090 
10091     // No need to mark vars as copyprivate, they are already threadprivate or
10092     // implicitly private.
10093     assert(VD || IsOpenMPCapturedDecl(D));
10094     Vars.push_back(
10095         VD ? RefExpr->IgnoreParens()
10096            : buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false));
10097     SrcExprs.push_back(PseudoSrcExpr);
10098     DstExprs.push_back(PseudoDstExpr);
10099     AssignmentOps.push_back(AssignmentOp.get());
10100   }
10101 
10102   if (Vars.empty())
10103     return nullptr;
10104 
10105   return OMPCopyprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10106                                       Vars, SrcExprs, DstExprs, AssignmentOps);
10107 }
10108 
ActOnOpenMPFlushClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)10109 OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
10110                                         SourceLocation StartLoc,
10111                                         SourceLocation LParenLoc,
10112                                         SourceLocation EndLoc) {
10113   if (VarList.empty())
10114     return nullptr;
10115 
10116   return OMPFlushClause::Create(Context, StartLoc, LParenLoc, EndLoc, VarList);
10117 }
10118 
10119 OMPClause *
ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind,SourceLocation DepLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)10120 Sema::ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind,
10121                               SourceLocation DepLoc, SourceLocation ColonLoc,
10122                               ArrayRef<Expr *> VarList, SourceLocation StartLoc,
10123                               SourceLocation LParenLoc, SourceLocation EndLoc) {
10124   if (DSAStack->getCurrentDirective() == OMPD_ordered &&
10125       DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink) {
10126     Diag(DepLoc, diag::err_omp_unexpected_clause_value)
10127         << "'source' or 'sink'" << getOpenMPClauseName(OMPC_depend);
10128     return nullptr;
10129   }
10130   if (DSAStack->getCurrentDirective() != OMPD_ordered &&
10131       (DepKind == OMPC_DEPEND_unknown || DepKind == OMPC_DEPEND_source ||
10132        DepKind == OMPC_DEPEND_sink)) {
10133     unsigned Except[] = {OMPC_DEPEND_source, OMPC_DEPEND_sink};
10134     Diag(DepLoc, diag::err_omp_unexpected_clause_value)
10135         << getListOfPossibleValues(OMPC_depend, /*First=*/0,
10136                                    /*Last=*/OMPC_DEPEND_unknown, Except)
10137         << getOpenMPClauseName(OMPC_depend);
10138     return nullptr;
10139   }
10140   SmallVector<Expr *, 8> Vars;
10141   DSAStackTy::OperatorOffsetTy OpsOffs;
10142   llvm::APSInt DepCounter(/*BitWidth=*/32);
10143   llvm::APSInt TotalDepCount(/*BitWidth=*/32);
10144   if (DepKind == OMPC_DEPEND_sink) {
10145     if (auto *OrderedCountExpr = DSAStack->getParentOrderedRegionParam()) {
10146       TotalDepCount = OrderedCountExpr->EvaluateKnownConstInt(Context);
10147       TotalDepCount.setIsUnsigned(/*Val=*/true);
10148     }
10149   }
10150   if ((DepKind != OMPC_DEPEND_sink && DepKind != OMPC_DEPEND_source) ||
10151       DSAStack->getParentOrderedRegionParam()) {
10152     for (auto &RefExpr : VarList) {
10153       assert(RefExpr && "NULL expr in OpenMP shared clause.");
10154       if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
10155         // It will be analyzed later.
10156         Vars.push_back(RefExpr);
10157         continue;
10158       }
10159 
10160       SourceLocation ELoc = RefExpr->getExprLoc();
10161       auto *SimpleExpr = RefExpr->IgnoreParenCasts();
10162       if (DepKind == OMPC_DEPEND_sink) {
10163         if (DepCounter >= TotalDepCount) {
10164           Diag(ELoc, diag::err_omp_depend_sink_unexpected_expr);
10165           continue;
10166         }
10167         ++DepCounter;
10168         // OpenMP  [2.13.9, Summary]
10169         // depend(dependence-type : vec), where dependence-type is:
10170         // 'sink' and where vec is the iteration vector, which has the form:
10171         //  x1 [+- d1], x2 [+- d2 ], . . . , xn [+- dn]
10172         // where n is the value specified by the ordered clause in the loop
10173         // directive, xi denotes the loop iteration variable of the i-th nested
10174         // loop associated with the loop directive, and di is a constant
10175         // non-negative integer.
10176         if (CurContext->isDependentContext()) {
10177           // It will be analyzed later.
10178           Vars.push_back(RefExpr);
10179           continue;
10180         }
10181         SimpleExpr = SimpleExpr->IgnoreImplicit();
10182         OverloadedOperatorKind OOK = OO_None;
10183         SourceLocation OOLoc;
10184         Expr *LHS = SimpleExpr;
10185         Expr *RHS = nullptr;
10186         if (auto *BO = dyn_cast<BinaryOperator>(SimpleExpr)) {
10187           OOK = BinaryOperator::getOverloadedOperator(BO->getOpcode());
10188           OOLoc = BO->getOperatorLoc();
10189           LHS = BO->getLHS()->IgnoreParenImpCasts();
10190           RHS = BO->getRHS()->IgnoreParenImpCasts();
10191         } else if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(SimpleExpr)) {
10192           OOK = OCE->getOperator();
10193           OOLoc = OCE->getOperatorLoc();
10194           LHS = OCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
10195           RHS = OCE->getArg(/*Arg=*/1)->IgnoreParenImpCasts();
10196         } else if (auto *MCE = dyn_cast<CXXMemberCallExpr>(SimpleExpr)) {
10197           OOK = MCE->getMethodDecl()
10198                     ->getNameInfo()
10199                     .getName()
10200                     .getCXXOverloadedOperator();
10201           OOLoc = MCE->getCallee()->getExprLoc();
10202           LHS = MCE->getImplicitObjectArgument()->IgnoreParenImpCasts();
10203           RHS = MCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
10204         }
10205         SourceLocation ELoc;
10206         SourceRange ERange;
10207         auto Res = getPrivateItem(*this, LHS, ELoc, ERange,
10208                                   /*AllowArraySection=*/false);
10209         if (Res.second) {
10210           // It will be analyzed later.
10211           Vars.push_back(RefExpr);
10212         }
10213         ValueDecl *D = Res.first;
10214         if (!D)
10215           continue;
10216 
10217         if (OOK != OO_Plus && OOK != OO_Minus && (RHS || OOK != OO_None)) {
10218           Diag(OOLoc, diag::err_omp_depend_sink_expected_plus_minus);
10219           continue;
10220         }
10221         if (RHS) {
10222           ExprResult RHSRes = VerifyPositiveIntegerConstantInClause(
10223               RHS, OMPC_depend, /*StrictlyPositive=*/false);
10224           if (RHSRes.isInvalid())
10225             continue;
10226         }
10227         if (!CurContext->isDependentContext() &&
10228             DSAStack->getParentOrderedRegionParam() &&
10229             DepCounter != DSAStack->isParentLoopControlVariable(D).first) {
10230           Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration)
10231               << DSAStack->getParentLoopControlVariable(
10232                      DepCounter.getZExtValue());
10233           continue;
10234         }
10235         OpsOffs.push_back({RHS, OOK});
10236       } else {
10237         // OpenMP  [2.11.1.1, Restrictions, p.3]
10238         //  A variable that is part of another variable (such as a field of a
10239         //  structure) but is not an array element or an array section cannot
10240         //  appear  in a depend clause.
10241         auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr);
10242         auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr);
10243         auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr);
10244         if (!RefExpr->IgnoreParenImpCasts()->isLValue() ||
10245             (!ASE && !DE && !OASE) || (DE && !isa<VarDecl>(DE->getDecl())) ||
10246             (ASE &&
10247              !ASE->getBase()
10248                   ->getType()
10249                   .getNonReferenceType()
10250                   ->isPointerType() &&
10251              !ASE->getBase()->getType().getNonReferenceType()->isArrayType())) {
10252           Diag(ELoc, diag::err_omp_expected_var_name_member_expr_or_array_item)
10253               << 0 << RefExpr->getSourceRange();
10254           continue;
10255         }
10256       }
10257       Vars.push_back(RefExpr->IgnoreParenImpCasts());
10258     }
10259 
10260     if (!CurContext->isDependentContext() && DepKind == OMPC_DEPEND_sink &&
10261         TotalDepCount > VarList.size() &&
10262         DSAStack->getParentOrderedRegionParam()) {
10263       Diag(EndLoc, diag::err_omp_depend_sink_expected_loop_iteration)
10264           << DSAStack->getParentLoopControlVariable(VarList.size() + 1);
10265     }
10266     if (DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink &&
10267         Vars.empty())
10268       return nullptr;
10269   }
10270   auto *C = OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10271                                     DepKind, DepLoc, ColonLoc, Vars);
10272   if (DepKind == OMPC_DEPEND_sink || DepKind == OMPC_DEPEND_source)
10273     DSAStack->addDoacrossDependClause(C, OpsOffs);
10274   return C;
10275 }
10276 
ActOnOpenMPDeviceClause(Expr * Device,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)10277 OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
10278                                          SourceLocation LParenLoc,
10279                                          SourceLocation EndLoc) {
10280   Expr *ValExpr = Device;
10281 
10282   // OpenMP [2.9.1, Restrictions]
10283   // The device expression must evaluate to a non-negative integer value.
10284   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_device,
10285                                  /*StrictlyPositive=*/false))
10286     return nullptr;
10287 
10288   return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10289 }
10290 
IsCXXRecordForMappable(Sema & SemaRef,SourceLocation Loc,DSAStackTy * Stack,CXXRecordDecl * RD)10291 static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc,
10292                                    DSAStackTy *Stack, CXXRecordDecl *RD) {
10293   if (!RD || RD->isInvalidDecl())
10294     return true;
10295 
10296   if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
10297     if (auto *CTD = CTSD->getSpecializedTemplate())
10298       RD = CTD->getTemplatedDecl();
10299   auto QTy = SemaRef.Context.getRecordType(RD);
10300   if (RD->isDynamicClass()) {
10301     SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10302     SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target);
10303     return false;
10304   }
10305   auto *DC = RD;
10306   bool IsCorrect = true;
10307   for (auto *I : DC->decls()) {
10308     if (I) {
10309       if (auto *MD = dyn_cast<CXXMethodDecl>(I)) {
10310         if (MD->isStatic()) {
10311           SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10312           SemaRef.Diag(MD->getLocation(),
10313                        diag::note_omp_static_member_in_target);
10314           IsCorrect = false;
10315         }
10316       } else if (auto *VD = dyn_cast<VarDecl>(I)) {
10317         if (VD->isStaticDataMember()) {
10318           SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10319           SemaRef.Diag(VD->getLocation(),
10320                        diag::note_omp_static_member_in_target);
10321           IsCorrect = false;
10322         }
10323       }
10324     }
10325   }
10326 
10327   for (auto &I : RD->bases()) {
10328     if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack,
10329                                 I.getType()->getAsCXXRecordDecl()))
10330       IsCorrect = false;
10331   }
10332   return IsCorrect;
10333 }
10334 
CheckTypeMappable(SourceLocation SL,SourceRange SR,Sema & SemaRef,DSAStackTy * Stack,QualType QTy)10335 static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
10336                               DSAStackTy *Stack, QualType QTy) {
10337   NamedDecl *ND;
10338   if (QTy->isIncompleteType(&ND)) {
10339     SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
10340     return false;
10341   } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) {
10342     if (!RD->isInvalidDecl() &&
10343         !IsCXXRecordForMappable(SemaRef, SL, Stack, RD))
10344       return false;
10345   }
10346   return true;
10347 }
10348 
10349 /// \brief Return true if it can be proven that the provided array expression
10350 /// (array section or array subscript) does NOT specify the whole size of the
10351 /// array whose base type is \a BaseQTy.
CheckArrayExpressionDoesNotReferToWholeSize(Sema & SemaRef,const Expr * E,QualType BaseQTy)10352 static bool CheckArrayExpressionDoesNotReferToWholeSize(Sema &SemaRef,
10353                                                         const Expr *E,
10354                                                         QualType BaseQTy) {
10355   auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
10356 
10357   // If this is an array subscript, it refers to the whole size if the size of
10358   // the dimension is constant and equals 1. Also, an array section assumes the
10359   // format of an array subscript if no colon is used.
10360   if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid())) {
10361     if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
10362       return ATy->getSize().getSExtValue() != 1;
10363     // Size can't be evaluated statically.
10364     return false;
10365   }
10366 
10367   assert(OASE && "Expecting array section if not an array subscript.");
10368   auto *LowerBound = OASE->getLowerBound();
10369   auto *Length = OASE->getLength();
10370 
10371   // If there is a lower bound that does not evaluates to zero, we are not
10372   // convering the whole dimension.
10373   if (LowerBound) {
10374     llvm::APSInt ConstLowerBound;
10375     if (!LowerBound->EvaluateAsInt(ConstLowerBound, SemaRef.getASTContext()))
10376       return false; // Can't get the integer value as a constant.
10377     if (ConstLowerBound.getSExtValue())
10378       return true;
10379   }
10380 
10381   // If we don't have a length we covering the whole dimension.
10382   if (!Length)
10383     return false;
10384 
10385   // If the base is a pointer, we don't have a way to get the size of the
10386   // pointee.
10387   if (BaseQTy->isPointerType())
10388     return false;
10389 
10390   // We can only check if the length is the same as the size of the dimension
10391   // if we have a constant array.
10392   auto *CATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr());
10393   if (!CATy)
10394     return false;
10395 
10396   llvm::APSInt ConstLength;
10397   if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
10398     return false; // Can't get the integer value as a constant.
10399 
10400   return CATy->getSize().getSExtValue() != ConstLength.getSExtValue();
10401 }
10402 
10403 // Return true if it can be proven that the provided array expression (array
10404 // section or array subscript) does NOT specify a single element of the array
10405 // whose base type is \a BaseQTy.
CheckArrayExpressionDoesNotReferToUnitySize(Sema & SemaRef,const Expr * E,QualType BaseQTy)10406 static bool CheckArrayExpressionDoesNotReferToUnitySize(Sema &SemaRef,
10407                                                        const Expr *E,
10408                                                        QualType BaseQTy) {
10409   auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
10410 
10411   // An array subscript always refer to a single element. Also, an array section
10412   // assumes the format of an array subscript if no colon is used.
10413   if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid()))
10414     return false;
10415 
10416   assert(OASE && "Expecting array section if not an array subscript.");
10417   auto *Length = OASE->getLength();
10418 
10419   // If we don't have a length we have to check if the array has unitary size
10420   // for this dimension. Also, we should always expect a length if the base type
10421   // is pointer.
10422   if (!Length) {
10423     if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
10424       return ATy->getSize().getSExtValue() != 1;
10425     // We cannot assume anything.
10426     return false;
10427   }
10428 
10429   // Check if the length evaluates to 1.
10430   llvm::APSInt ConstLength;
10431   if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
10432     return false; // Can't get the integer value as a constant.
10433 
10434   return ConstLength.getSExtValue() != 1;
10435 }
10436 
10437 // Return the expression of the base of the mappable expression or null if it
10438 // cannot be determined and do all the necessary checks to see if the expression
10439 // is valid as a standalone mappable expression. In the process, record all the
10440 // components of the expression.
CheckMapClauseExpressionBase(Sema & SemaRef,Expr * E,OMPClauseMappableExprCommon::MappableExprComponentList & CurComponents,OpenMPClauseKind CKind)10441 static Expr *CheckMapClauseExpressionBase(
10442     Sema &SemaRef, Expr *E,
10443     OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents,
10444     OpenMPClauseKind CKind) {
10445   SourceLocation ELoc = E->getExprLoc();
10446   SourceRange ERange = E->getSourceRange();
10447 
10448   // The base of elements of list in a map clause have to be either:
10449   //  - a reference to variable or field.
10450   //  - a member expression.
10451   //  - an array expression.
10452   //
10453   // E.g. if we have the expression 'r.S.Arr[:12]', we want to retrieve the
10454   // reference to 'r'.
10455   //
10456   // If we have:
10457   //
10458   // struct SS {
10459   //   Bla S;
10460   //   foo() {
10461   //     #pragma omp target map (S.Arr[:12]);
10462   //   }
10463   // }
10464   //
10465   // We want to retrieve the member expression 'this->S';
10466 
10467   Expr *RelevantExpr = nullptr;
10468 
10469   // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.2]
10470   //  If a list item is an array section, it must specify contiguous storage.
10471   //
10472   // For this restriction it is sufficient that we make sure only references
10473   // to variables or fields and array expressions, and that no array sections
10474   // exist except in the rightmost expression (unless they cover the whole
10475   // dimension of the array). E.g. these would be invalid:
10476   //
10477   //   r.ArrS[3:5].Arr[6:7]
10478   //
10479   //   r.ArrS[3:5].x
10480   //
10481   // but these would be valid:
10482   //   r.ArrS[3].Arr[6:7]
10483   //
10484   //   r.ArrS[3].x
10485 
10486   bool AllowUnitySizeArraySection = true;
10487   bool AllowWholeSizeArraySection = true;
10488 
10489   while (!RelevantExpr) {
10490     E = E->IgnoreParenImpCasts();
10491 
10492     if (auto *CurE = dyn_cast<DeclRefExpr>(E)) {
10493       if (!isa<VarDecl>(CurE->getDecl()))
10494         break;
10495 
10496       RelevantExpr = CurE;
10497 
10498       // If we got a reference to a declaration, we should not expect any array
10499       // section before that.
10500       AllowUnitySizeArraySection = false;
10501       AllowWholeSizeArraySection = false;
10502 
10503       // Record the component.
10504       CurComponents.push_back(OMPClauseMappableExprCommon::MappableComponent(
10505           CurE, CurE->getDecl()));
10506       continue;
10507     }
10508 
10509     if (auto *CurE = dyn_cast<MemberExpr>(E)) {
10510       auto *BaseE = CurE->getBase()->IgnoreParenImpCasts();
10511 
10512       if (isa<CXXThisExpr>(BaseE))
10513         // We found a base expression: this->Val.
10514         RelevantExpr = CurE;
10515       else
10516         E = BaseE;
10517 
10518       if (!isa<FieldDecl>(CurE->getMemberDecl())) {
10519         SemaRef.Diag(ELoc, diag::err_omp_expected_access_to_data_field)
10520             << CurE->getSourceRange();
10521         break;
10522       }
10523 
10524       auto *FD = cast<FieldDecl>(CurE->getMemberDecl());
10525 
10526       // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3]
10527       //  A bit-field cannot appear in a map clause.
10528       //
10529       if (FD->isBitField()) {
10530         SemaRef.Diag(ELoc, diag::err_omp_bit_fields_forbidden_in_clause)
10531             << CurE->getSourceRange() << getOpenMPClauseName(CKind);
10532         break;
10533       }
10534 
10535       // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10536       //  If the type of a list item is a reference to a type T then the type
10537       //  will be considered to be T for all purposes of this clause.
10538       QualType CurType = BaseE->getType().getNonReferenceType();
10539 
10540       // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.2]
10541       //  A list item cannot be a variable that is a member of a structure with
10542       //  a union type.
10543       //
10544       if (auto *RT = CurType->getAs<RecordType>())
10545         if (RT->isUnionType()) {
10546           SemaRef.Diag(ELoc, diag::err_omp_union_type_not_allowed)
10547               << CurE->getSourceRange();
10548           break;
10549         }
10550 
10551       // If we got a member expression, we should not expect any array section
10552       // before that:
10553       //
10554       // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7]
10555       //  If a list item is an element of a structure, only the rightmost symbol
10556       //  of the variable reference can be an array section.
10557       //
10558       AllowUnitySizeArraySection = false;
10559       AllowWholeSizeArraySection = false;
10560 
10561       // Record the component.
10562       CurComponents.push_back(
10563           OMPClauseMappableExprCommon::MappableComponent(CurE, FD));
10564       continue;
10565     }
10566 
10567     if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) {
10568       E = CurE->getBase()->IgnoreParenImpCasts();
10569 
10570       if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) {
10571         SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
10572             << 0 << CurE->getSourceRange();
10573         break;
10574       }
10575 
10576       // If we got an array subscript that express the whole dimension we
10577       // can have any array expressions before. If it only expressing part of
10578       // the dimension, we can only have unitary-size array expressions.
10579       if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE,
10580                                                       E->getType()))
10581         AllowWholeSizeArraySection = false;
10582 
10583       // Record the component - we don't have any declaration associated.
10584       CurComponents.push_back(
10585           OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
10586       continue;
10587     }
10588 
10589     if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) {
10590       E = CurE->getBase()->IgnoreParenImpCasts();
10591 
10592       auto CurType =
10593           OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
10594 
10595       // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10596       //  If the type of a list item is a reference to a type T then the type
10597       //  will be considered to be T for all purposes of this clause.
10598       if (CurType->isReferenceType())
10599         CurType = CurType->getPointeeType();
10600 
10601       bool IsPointer = CurType->isAnyPointerType();
10602 
10603       if (!IsPointer && !CurType->isArrayType()) {
10604         SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
10605             << 0 << CurE->getSourceRange();
10606         break;
10607       }
10608 
10609       bool NotWhole =
10610           CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, CurType);
10611       bool NotUnity =
10612           CheckArrayExpressionDoesNotReferToUnitySize(SemaRef, CurE, CurType);
10613 
10614       if (AllowWholeSizeArraySection && AllowUnitySizeArraySection) {
10615         // Any array section is currently allowed.
10616         //
10617         // If this array section refers to the whole dimension we can still
10618         // accept other array sections before this one, except if the base is a
10619         // pointer. Otherwise, only unitary sections are accepted.
10620         if (NotWhole || IsPointer)
10621           AllowWholeSizeArraySection = false;
10622       } else if ((AllowUnitySizeArraySection && NotUnity) ||
10623                  (AllowWholeSizeArraySection && NotWhole)) {
10624         // A unity or whole array section is not allowed and that is not
10625         // compatible with the properties of the current array section.
10626         SemaRef.Diag(
10627             ELoc, diag::err_array_section_does_not_specify_contiguous_storage)
10628             << CurE->getSourceRange();
10629         break;
10630       }
10631 
10632       // Record the component - we don't have any declaration associated.
10633       CurComponents.push_back(
10634           OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
10635       continue;
10636     }
10637 
10638     // If nothing else worked, this is not a valid map clause expression.
10639     SemaRef.Diag(ELoc,
10640                  diag::err_omp_expected_named_var_member_or_array_expression)
10641         << ERange;
10642     break;
10643   }
10644 
10645   return RelevantExpr;
10646 }
10647 
10648 // Return true if expression E associated with value VD has conflicts with other
10649 // map information.
CheckMapConflicts(Sema & SemaRef,DSAStackTy * DSAS,ValueDecl * VD,Expr * E,bool CurrentRegionOnly,OMPClauseMappableExprCommon::MappableExprComponentListRef CurComponents,OpenMPClauseKind CKind)10650 static bool CheckMapConflicts(
10651     Sema &SemaRef, DSAStackTy *DSAS, ValueDecl *VD, Expr *E,
10652     bool CurrentRegionOnly,
10653     OMPClauseMappableExprCommon::MappableExprComponentListRef CurComponents,
10654     OpenMPClauseKind CKind) {
10655   assert(VD && E);
10656   SourceLocation ELoc = E->getExprLoc();
10657   SourceRange ERange = E->getSourceRange();
10658 
10659   // In order to easily check the conflicts we need to match each component of
10660   // the expression under test with the components of the expressions that are
10661   // already in the stack.
10662 
10663   assert(!CurComponents.empty() && "Map clause expression with no components!");
10664   assert(CurComponents.back().getAssociatedDeclaration() == VD &&
10665          "Map clause expression with unexpected base!");
10666 
10667   // Variables to help detecting enclosing problems in data environment nests.
10668   bool IsEnclosedByDataEnvironmentExpr = false;
10669   const Expr *EnclosingExpr = nullptr;
10670 
10671   bool FoundError = DSAS->checkMappableExprComponentListsForDecl(
10672       VD, CurrentRegionOnly,
10673       [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
10674               StackComponents) -> bool {
10675 
10676         assert(!StackComponents.empty() &&
10677                "Map clause expression with no components!");
10678         assert(StackComponents.back().getAssociatedDeclaration() == VD &&
10679                "Map clause expression with unexpected base!");
10680 
10681         // The whole expression in the stack.
10682         auto *RE = StackComponents.front().getAssociatedExpression();
10683 
10684         // Expressions must start from the same base. Here we detect at which
10685         // point both expressions diverge from each other and see if we can
10686         // detect if the memory referred to both expressions is contiguous and
10687         // do not overlap.
10688         auto CI = CurComponents.rbegin();
10689         auto CE = CurComponents.rend();
10690         auto SI = StackComponents.rbegin();
10691         auto SE = StackComponents.rend();
10692         for (; CI != CE && SI != SE; ++CI, ++SI) {
10693 
10694           // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.3]
10695           //  At most one list item can be an array item derived from a given
10696           //  variable in map clauses of the same construct.
10697           if (CurrentRegionOnly &&
10698               (isa<ArraySubscriptExpr>(CI->getAssociatedExpression()) ||
10699                isa<OMPArraySectionExpr>(CI->getAssociatedExpression())) &&
10700               (isa<ArraySubscriptExpr>(SI->getAssociatedExpression()) ||
10701                isa<OMPArraySectionExpr>(SI->getAssociatedExpression()))) {
10702             SemaRef.Diag(CI->getAssociatedExpression()->getExprLoc(),
10703                          diag::err_omp_multiple_array_items_in_map_clause)
10704                 << CI->getAssociatedExpression()->getSourceRange();
10705             SemaRef.Diag(SI->getAssociatedExpression()->getExprLoc(),
10706                          diag::note_used_here)
10707                 << SI->getAssociatedExpression()->getSourceRange();
10708             return true;
10709           }
10710 
10711           // Do both expressions have the same kind?
10712           if (CI->getAssociatedExpression()->getStmtClass() !=
10713               SI->getAssociatedExpression()->getStmtClass())
10714             break;
10715 
10716           // Are we dealing with different variables/fields?
10717           if (CI->getAssociatedDeclaration() != SI->getAssociatedDeclaration())
10718             break;
10719         }
10720 
10721         // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10722         //  List items of map clauses in the same construct must not share
10723         //  original storage.
10724         //
10725         // If the expressions are exactly the same or one is a subset of the
10726         // other, it means they are sharing storage.
10727         if (CI == CE && SI == SE) {
10728           if (CurrentRegionOnly) {
10729             if (CKind == OMPC_map)
10730               SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10731             else {
10732               assert(CKind == OMPC_to || CKind == OMPC_from);
10733               SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10734                   << ERange;
10735             }
10736             SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10737                 << RE->getSourceRange();
10738             return true;
10739           } else {
10740             // If we find the same expression in the enclosing data environment,
10741             // that is legal.
10742             IsEnclosedByDataEnvironmentExpr = true;
10743             return false;
10744           }
10745         }
10746 
10747         QualType DerivedType =
10748             std::prev(CI)->getAssociatedDeclaration()->getType();
10749         SourceLocation DerivedLoc =
10750             std::prev(CI)->getAssociatedExpression()->getExprLoc();
10751 
10752         // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10753         //  If the type of a list item is a reference to a type T then the type
10754         //  will be considered to be T for all purposes of this clause.
10755         DerivedType = DerivedType.getNonReferenceType();
10756 
10757         // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.1]
10758         //  A variable for which the type is pointer and an array section
10759         //  derived from that variable must not appear as list items of map
10760         //  clauses of the same construct.
10761         //
10762         // Also, cover one of the cases in:
10763         // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10764         //  If any part of the original storage of a list item has corresponding
10765         //  storage in the device data environment, all of the original storage
10766         //  must have corresponding storage in the device data environment.
10767         //
10768         if (DerivedType->isAnyPointerType()) {
10769           if (CI == CE || SI == SE) {
10770             SemaRef.Diag(
10771                 DerivedLoc,
10772                 diag::err_omp_pointer_mapped_along_with_derived_section)
10773                 << DerivedLoc;
10774           } else {
10775             assert(CI != CE && SI != SE);
10776             SemaRef.Diag(DerivedLoc, diag::err_omp_same_pointer_derreferenced)
10777                 << DerivedLoc;
10778           }
10779           SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10780               << RE->getSourceRange();
10781           return true;
10782         }
10783 
10784         // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10785         //  List items of map clauses in the same construct must not share
10786         //  original storage.
10787         //
10788         // An expression is a subset of the other.
10789         if (CurrentRegionOnly && (CI == CE || SI == SE)) {
10790           if (CKind == OMPC_map)
10791             SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10792           else {
10793             assert(CKind == OMPC_to || CKind == OMPC_from);
10794             SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10795                 << ERange;
10796           }
10797           SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10798               << RE->getSourceRange();
10799           return true;
10800         }
10801 
10802         // The current expression uses the same base as other expression in the
10803         // data environment but does not contain it completely.
10804         if (!CurrentRegionOnly && SI != SE)
10805           EnclosingExpr = RE;
10806 
10807         // The current expression is a subset of the expression in the data
10808         // environment.
10809         IsEnclosedByDataEnvironmentExpr |=
10810             (!CurrentRegionOnly && CI != CE && SI == SE);
10811 
10812         return false;
10813       });
10814 
10815   if (CurrentRegionOnly)
10816     return FoundError;
10817 
10818   // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10819   //  If any part of the original storage of a list item has corresponding
10820   //  storage in the device data environment, all of the original storage must
10821   //  have corresponding storage in the device data environment.
10822   // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.6]
10823   //  If a list item is an element of a structure, and a different element of
10824   //  the structure has a corresponding list item in the device data environment
10825   //  prior to a task encountering the construct associated with the map clause,
10826   //  then the list item must also have a corresponding list item in the device
10827   //  data environment prior to the task encountering the construct.
10828   //
10829   if (EnclosingExpr && !IsEnclosedByDataEnvironmentExpr) {
10830     SemaRef.Diag(ELoc,
10831                  diag::err_omp_original_storage_is_shared_and_does_not_contain)
10832         << ERange;
10833     SemaRef.Diag(EnclosingExpr->getExprLoc(), diag::note_used_here)
10834         << EnclosingExpr->getSourceRange();
10835     return true;
10836   }
10837 
10838   return FoundError;
10839 }
10840 
10841 namespace {
10842 // Utility struct that gathers all the related lists associated with a mappable
10843 // expression.
10844 struct MappableVarListInfo final {
10845   // The list of expressions.
10846   ArrayRef<Expr *> VarList;
10847   // The list of processed expressions.
10848   SmallVector<Expr *, 16> ProcessedVarList;
10849   // The mappble components for each expression.
10850   OMPClauseMappableExprCommon::MappableExprComponentLists VarComponents;
10851   // The base declaration of the variable.
10852   SmallVector<ValueDecl *, 16> VarBaseDeclarations;
10853 
MappableVarListInfo__anon94996c652d11::MappableVarListInfo10854   MappableVarListInfo(ArrayRef<Expr *> VarList) : VarList(VarList) {
10855     // We have a list of components and base declarations for each entry in the
10856     // variable list.
10857     VarComponents.reserve(VarList.size());
10858     VarBaseDeclarations.reserve(VarList.size());
10859   }
10860 };
10861 }
10862 
10863 // Check the validity of the provided variable list for the provided clause kind
10864 // \a CKind. In the check process the valid expressions, and mappable expression
10865 // components and variables are extracted and used to fill \a Vars,
10866 // \a ClauseComponents, and \a ClauseBaseDeclarations. \a MapType and
10867 // \a IsMapTypeImplicit are expected to be valid if the clause kind is 'map'.
10868 static void
checkMappableExpressionList(Sema & SemaRef,DSAStackTy * DSAS,OpenMPClauseKind CKind,MappableVarListInfo & MVLI,SourceLocation StartLoc,OpenMPMapClauseKind MapType=OMPC_MAP_unknown,bool IsMapTypeImplicit=false)10869 checkMappableExpressionList(Sema &SemaRef, DSAStackTy *DSAS,
10870                             OpenMPClauseKind CKind, MappableVarListInfo &MVLI,
10871                             SourceLocation StartLoc,
10872                             OpenMPMapClauseKind MapType = OMPC_MAP_unknown,
10873                             bool IsMapTypeImplicit = false) {
10874   // We only expect mappable expressions in 'to', 'from', and 'map' clauses.
10875   assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from) &&
10876          "Unexpected clause kind with mappable expressions!");
10877 
10878   // Keep track of the mappable components and base declarations in this clause.
10879   // Each entry in the list is going to have a list of components associated. We
10880   // record each set of the components so that we can build the clause later on.
10881   // In the end we should have the same amount of declarations and component
10882   // lists.
10883 
10884   for (auto &RE : MVLI.VarList) {
10885     assert(RE && "Null expr in omp to/from/map clause");
10886     SourceLocation ELoc = RE->getExprLoc();
10887 
10888     auto *VE = RE->IgnoreParenLValueCasts();
10889 
10890     if (VE->isValueDependent() || VE->isTypeDependent() ||
10891         VE->isInstantiationDependent() ||
10892         VE->containsUnexpandedParameterPack()) {
10893       // We can only analyze this information once the missing information is
10894       // resolved.
10895       MVLI.ProcessedVarList.push_back(RE);
10896       continue;
10897     }
10898 
10899     auto *SimpleExpr = RE->IgnoreParenCasts();
10900 
10901     if (!RE->IgnoreParenImpCasts()->isLValue()) {
10902       SemaRef.Diag(ELoc,
10903                    diag::err_omp_expected_named_var_member_or_array_expression)
10904           << RE->getSourceRange();
10905       continue;
10906     }
10907 
10908     OMPClauseMappableExprCommon::MappableExprComponentList CurComponents;
10909     ValueDecl *CurDeclaration = nullptr;
10910 
10911     // Obtain the array or member expression bases if required. Also, fill the
10912     // components array with all the components identified in the process.
10913     auto *BE =
10914         CheckMapClauseExpressionBase(SemaRef, SimpleExpr, CurComponents, CKind);
10915     if (!BE)
10916       continue;
10917 
10918     assert(!CurComponents.empty() &&
10919            "Invalid mappable expression information.");
10920 
10921     // For the following checks, we rely on the base declaration which is
10922     // expected to be associated with the last component. The declaration is
10923     // expected to be a variable or a field (if 'this' is being mapped).
10924     CurDeclaration = CurComponents.back().getAssociatedDeclaration();
10925     assert(CurDeclaration && "Null decl on map clause.");
10926     assert(
10927         CurDeclaration->isCanonicalDecl() &&
10928         "Expecting components to have associated only canonical declarations.");
10929 
10930     auto *VD = dyn_cast<VarDecl>(CurDeclaration);
10931     auto *FD = dyn_cast<FieldDecl>(CurDeclaration);
10932 
10933     assert((VD || FD) && "Only variables or fields are expected here!");
10934     (void)FD;
10935 
10936     // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.10]
10937     // threadprivate variables cannot appear in a map clause.
10938     // OpenMP 4.5 [2.10.5, target update Construct]
10939     // threadprivate variables cannot appear in a from clause.
10940     if (VD && DSAS->isThreadPrivate(VD)) {
10941       auto DVar = DSAS->getTopDSA(VD, false);
10942       SemaRef.Diag(ELoc, diag::err_omp_threadprivate_in_clause)
10943           << getOpenMPClauseName(CKind);
10944       ReportOriginalDSA(SemaRef, DSAS, VD, DVar);
10945       continue;
10946     }
10947 
10948     // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10949     //  A list item cannot appear in both a map clause and a data-sharing
10950     //  attribute clause on the same construct.
10951 
10952     // Check conflicts with other map clause expressions. We check the conflicts
10953     // with the current construct separately from the enclosing data
10954     // environment, because the restrictions are different. We only have to
10955     // check conflicts across regions for the map clauses.
10956     if (CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10957                           /*CurrentRegionOnly=*/true, CurComponents, CKind))
10958       break;
10959     if (CKind == OMPC_map &&
10960         CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10961                           /*CurrentRegionOnly=*/false, CurComponents, CKind))
10962       break;
10963 
10964     // OpenMP 4.5 [2.10.5, target update Construct]
10965     // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10966     //  If the type of a list item is a reference to a type T then the type will
10967     //  be considered to be T for all purposes of this clause.
10968     QualType Type = CurDeclaration->getType().getNonReferenceType();
10969 
10970     // OpenMP 4.5 [2.10.5, target update Construct, Restrictions, p.4]
10971     // A list item in a to or from clause must have a mappable type.
10972     // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10973     //  A list item must have a mappable type.
10974     if (!CheckTypeMappable(VE->getExprLoc(), VE->getSourceRange(), SemaRef,
10975                            DSAS, Type))
10976       continue;
10977 
10978     if (CKind == OMPC_map) {
10979       // target enter data
10980       // OpenMP [2.10.2, Restrictions, p. 99]
10981       // A map-type must be specified in all map clauses and must be either
10982       // to or alloc.
10983       OpenMPDirectiveKind DKind = DSAS->getCurrentDirective();
10984       if (DKind == OMPD_target_enter_data &&
10985           !(MapType == OMPC_MAP_to || MapType == OMPC_MAP_alloc)) {
10986         SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10987             << (IsMapTypeImplicit ? 1 : 0)
10988             << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10989             << getOpenMPDirectiveName(DKind);
10990         continue;
10991       }
10992 
10993       // target exit_data
10994       // OpenMP [2.10.3, Restrictions, p. 102]
10995       // A map-type must be specified in all map clauses and must be either
10996       // from, release, or delete.
10997       if (DKind == OMPD_target_exit_data &&
10998           !(MapType == OMPC_MAP_from || MapType == OMPC_MAP_release ||
10999             MapType == OMPC_MAP_delete)) {
11000         SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
11001             << (IsMapTypeImplicit ? 1 : 0)
11002             << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
11003             << getOpenMPDirectiveName(DKind);
11004         continue;
11005       }
11006 
11007       // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
11008       // A list item cannot appear in both a map clause and a data-sharing
11009       // attribute clause on the same construct
11010       if (DKind == OMPD_target && VD) {
11011         auto DVar = DSAS->getTopDSA(VD, false);
11012         if (isOpenMPPrivate(DVar.CKind)) {
11013           SemaRef.Diag(ELoc, diag::err_omp_variable_in_map_and_dsa)
11014               << getOpenMPClauseName(DVar.CKind)
11015               << getOpenMPDirectiveName(DSAS->getCurrentDirective());
11016           ReportOriginalDSA(SemaRef, DSAS, CurDeclaration, DVar);
11017           continue;
11018         }
11019       }
11020     }
11021 
11022     // Save the current expression.
11023     MVLI.ProcessedVarList.push_back(RE);
11024 
11025     // Store the components in the stack so that they can be used to check
11026     // against other clauses later on.
11027     DSAS->addMappableExpressionComponents(CurDeclaration, CurComponents);
11028 
11029     // Save the components and declaration to create the clause. For purposes of
11030     // the clause creation, any component list that has has base 'this' uses
11031     // null as base declaration.
11032     MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
11033     MVLI.VarComponents.back().append(CurComponents.begin(),
11034                                      CurComponents.end());
11035     MVLI.VarBaseDeclarations.push_back(isa<MemberExpr>(BE) ? nullptr
11036                                                            : CurDeclaration);
11037   }
11038 }
11039 
11040 OMPClause *
ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,OpenMPMapClauseKind MapType,bool IsMapTypeImplicit,SourceLocation MapLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11041 Sema::ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,
11042                            OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
11043                            SourceLocation MapLoc, SourceLocation ColonLoc,
11044                            ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11045                            SourceLocation LParenLoc, SourceLocation EndLoc) {
11046   MappableVarListInfo MVLI(VarList);
11047   checkMappableExpressionList(*this, DSAStack, OMPC_map, MVLI, StartLoc,
11048                               MapType, IsMapTypeImplicit);
11049 
11050   // We need to produce a map clause even if we don't have variables so that
11051   // other diagnostics related with non-existing map clauses are accurate.
11052   return OMPMapClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11053                               MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11054                               MVLI.VarComponents, MapTypeModifier, MapType,
11055                               IsMapTypeImplicit, MapLoc);
11056 }
11057 
ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,TypeResult ParsedType)11058 QualType Sema::ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
11059                                                TypeResult ParsedType) {
11060   assert(ParsedType.isUsable());
11061 
11062   QualType ReductionType = GetTypeFromParser(ParsedType.get());
11063   if (ReductionType.isNull())
11064     return QualType();
11065 
11066   // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions, C\C++
11067   // A type name in a declare reduction directive cannot be a function type, an
11068   // array type, a reference type, or a type qualified with const, volatile or
11069   // restrict.
11070   if (ReductionType.hasQualifiers()) {
11071     Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 0;
11072     return QualType();
11073   }
11074 
11075   if (ReductionType->isFunctionType()) {
11076     Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 1;
11077     return QualType();
11078   }
11079   if (ReductionType->isReferenceType()) {
11080     Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 2;
11081     return QualType();
11082   }
11083   if (ReductionType->isArrayType()) {
11084     Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 3;
11085     return QualType();
11086   }
11087   return ReductionType;
11088 }
11089 
ActOnOpenMPDeclareReductionDirectiveStart(Scope * S,DeclContext * DC,DeclarationName Name,ArrayRef<std::pair<QualType,SourceLocation>> ReductionTypes,AccessSpecifier AS,Decl * PrevDeclInScope)11090 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveStart(
11091     Scope *S, DeclContext *DC, DeclarationName Name,
11092     ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
11093     AccessSpecifier AS, Decl *PrevDeclInScope) {
11094   SmallVector<Decl *, 8> Decls;
11095   Decls.reserve(ReductionTypes.size());
11096 
11097   LookupResult Lookup(*this, Name, SourceLocation(), LookupOMPReductionName,
11098                       ForRedeclaration);
11099   // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
11100   // A reduction-identifier may not be re-declared in the current scope for the
11101   // same type or for a type that is compatible according to the base language
11102   // rules.
11103   llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
11104   OMPDeclareReductionDecl *PrevDRD = nullptr;
11105   bool InCompoundScope = true;
11106   if (S != nullptr) {
11107     // Find previous declaration with the same name not referenced in other
11108     // declarations.
11109     FunctionScopeInfo *ParentFn = getEnclosingFunction();
11110     InCompoundScope =
11111         (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty();
11112     LookupName(Lookup, S);
11113     FilterLookupForScope(Lookup, DC, S, /*ConsiderLinkage=*/false,
11114                          /*AllowInlineNamespace=*/false);
11115     llvm::DenseMap<OMPDeclareReductionDecl *, bool> UsedAsPrevious;
11116     auto Filter = Lookup.makeFilter();
11117     while (Filter.hasNext()) {
11118       auto *PrevDecl = cast<OMPDeclareReductionDecl>(Filter.next());
11119       if (InCompoundScope) {
11120         auto I = UsedAsPrevious.find(PrevDecl);
11121         if (I == UsedAsPrevious.end())
11122           UsedAsPrevious[PrevDecl] = false;
11123         if (auto *D = PrevDecl->getPrevDeclInScope())
11124           UsedAsPrevious[D] = true;
11125       }
11126       PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] =
11127           PrevDecl->getLocation();
11128     }
11129     Filter.done();
11130     if (InCompoundScope) {
11131       for (auto &PrevData : UsedAsPrevious) {
11132         if (!PrevData.second) {
11133           PrevDRD = PrevData.first;
11134           break;
11135         }
11136       }
11137     }
11138   } else if (PrevDeclInScope != nullptr) {
11139     auto *PrevDRDInScope = PrevDRD =
11140         cast<OMPDeclareReductionDecl>(PrevDeclInScope);
11141     do {
11142       PreviousRedeclTypes[PrevDRDInScope->getType().getCanonicalType()] =
11143           PrevDRDInScope->getLocation();
11144       PrevDRDInScope = PrevDRDInScope->getPrevDeclInScope();
11145     } while (PrevDRDInScope != nullptr);
11146   }
11147   for (auto &TyData : ReductionTypes) {
11148     auto I = PreviousRedeclTypes.find(TyData.first.getCanonicalType());
11149     bool Invalid = false;
11150     if (I != PreviousRedeclTypes.end()) {
11151       Diag(TyData.second, diag::err_omp_declare_reduction_redefinition)
11152           << TyData.first;
11153       Diag(I->second, diag::note_previous_definition);
11154       Invalid = true;
11155     }
11156     PreviousRedeclTypes[TyData.first.getCanonicalType()] = TyData.second;
11157     auto *DRD = OMPDeclareReductionDecl::Create(Context, DC, TyData.second,
11158                                                 Name, TyData.first, PrevDRD);
11159     DC->addDecl(DRD);
11160     DRD->setAccess(AS);
11161     Decls.push_back(DRD);
11162     if (Invalid)
11163       DRD->setInvalidDecl();
11164     else
11165       PrevDRD = DRD;
11166   }
11167 
11168   return DeclGroupPtrTy::make(
11169       DeclGroupRef::Create(Context, Decls.begin(), Decls.size()));
11170 }
11171 
ActOnOpenMPDeclareReductionCombinerStart(Scope * S,Decl * D)11172 void Sema::ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D) {
11173   auto *DRD = cast<OMPDeclareReductionDecl>(D);
11174 
11175   // Enter new function scope.
11176   PushFunctionScope();
11177   getCurFunction()->setHasBranchProtectedScope();
11178   getCurFunction()->setHasOMPDeclareReductionCombiner();
11179 
11180   if (S != nullptr)
11181     PushDeclContext(S, DRD);
11182   else
11183     CurContext = DRD;
11184 
11185   PushExpressionEvaluationContext(PotentiallyEvaluated);
11186 
11187   QualType ReductionType = DRD->getType();
11188   // Create 'T* omp_parm;T omp_in;'. All references to 'omp_in' will
11189   // be replaced by '*omp_parm' during codegen. This required because 'omp_in'
11190   // uses semantics of argument handles by value, but it should be passed by
11191   // reference. C lang does not support references, so pass all parameters as
11192   // pointers.
11193   // Create 'T omp_in;' variable.
11194   auto *OmpInParm =
11195       buildVarDecl(*this, D->getLocation(), ReductionType, "omp_in");
11196   // Create 'T* omp_parm;T omp_out;'. All references to 'omp_out' will
11197   // be replaced by '*omp_parm' during codegen. This required because 'omp_out'
11198   // uses semantics of argument handles by value, but it should be passed by
11199   // reference. C lang does not support references, so pass all parameters as
11200   // pointers.
11201   // Create 'T omp_out;' variable.
11202   auto *OmpOutParm =
11203       buildVarDecl(*this, D->getLocation(), ReductionType, "omp_out");
11204   if (S != nullptr) {
11205     PushOnScopeChains(OmpInParm, S);
11206     PushOnScopeChains(OmpOutParm, S);
11207   } else {
11208     DRD->addDecl(OmpInParm);
11209     DRD->addDecl(OmpOutParm);
11210   }
11211 }
11212 
ActOnOpenMPDeclareReductionCombinerEnd(Decl * D,Expr * Combiner)11213 void Sema::ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner) {
11214   auto *DRD = cast<OMPDeclareReductionDecl>(D);
11215   DiscardCleanupsInEvaluationContext();
11216   PopExpressionEvaluationContext();
11217 
11218   PopDeclContext();
11219   PopFunctionScopeInfo();
11220 
11221   if (Combiner != nullptr)
11222     DRD->setCombiner(Combiner);
11223   else
11224     DRD->setInvalidDecl();
11225 }
11226 
ActOnOpenMPDeclareReductionInitializerStart(Scope * S,Decl * D)11227 void Sema::ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D) {
11228   auto *DRD = cast<OMPDeclareReductionDecl>(D);
11229 
11230   // Enter new function scope.
11231   PushFunctionScope();
11232   getCurFunction()->setHasBranchProtectedScope();
11233 
11234   if (S != nullptr)
11235     PushDeclContext(S, DRD);
11236   else
11237     CurContext = DRD;
11238 
11239   PushExpressionEvaluationContext(PotentiallyEvaluated);
11240 
11241   QualType ReductionType = DRD->getType();
11242   // Create 'T* omp_parm;T omp_priv;'. All references to 'omp_priv' will
11243   // be replaced by '*omp_parm' during codegen. This required because 'omp_priv'
11244   // uses semantics of argument handles by value, but it should be passed by
11245   // reference. C lang does not support references, so pass all parameters as
11246   // pointers.
11247   // Create 'T omp_priv;' variable.
11248   auto *OmpPrivParm =
11249       buildVarDecl(*this, D->getLocation(), ReductionType, "omp_priv");
11250   // Create 'T* omp_parm;T omp_orig;'. All references to 'omp_orig' will
11251   // be replaced by '*omp_parm' during codegen. This required because 'omp_orig'
11252   // uses semantics of argument handles by value, but it should be passed by
11253   // reference. C lang does not support references, so pass all parameters as
11254   // pointers.
11255   // Create 'T omp_orig;' variable.
11256   auto *OmpOrigParm =
11257       buildVarDecl(*this, D->getLocation(), ReductionType, "omp_orig");
11258   if (S != nullptr) {
11259     PushOnScopeChains(OmpPrivParm, S);
11260     PushOnScopeChains(OmpOrigParm, S);
11261   } else {
11262     DRD->addDecl(OmpPrivParm);
11263     DRD->addDecl(OmpOrigParm);
11264   }
11265 }
11266 
ActOnOpenMPDeclareReductionInitializerEnd(Decl * D,Expr * Initializer)11267 void Sema::ActOnOpenMPDeclareReductionInitializerEnd(Decl *D,
11268                                                      Expr *Initializer) {
11269   auto *DRD = cast<OMPDeclareReductionDecl>(D);
11270   DiscardCleanupsInEvaluationContext();
11271   PopExpressionEvaluationContext();
11272 
11273   PopDeclContext();
11274   PopFunctionScopeInfo();
11275 
11276   if (Initializer != nullptr)
11277     DRD->setInitializer(Initializer);
11278   else
11279     DRD->setInvalidDecl();
11280 }
11281 
ActOnOpenMPDeclareReductionDirectiveEnd(Scope * S,DeclGroupPtrTy DeclReductions,bool IsValid)11282 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveEnd(
11283     Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid) {
11284   for (auto *D : DeclReductions.get()) {
11285     if (IsValid) {
11286       auto *DRD = cast<OMPDeclareReductionDecl>(D);
11287       if (S != nullptr)
11288         PushOnScopeChains(DRD, S, /*AddToContext=*/false);
11289     } else
11290       D->setInvalidDecl();
11291   }
11292   return DeclReductions;
11293 }
11294 
ActOnOpenMPNumTeamsClause(Expr * NumTeams,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11295 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams,
11296                                            SourceLocation StartLoc,
11297                                            SourceLocation LParenLoc,
11298                                            SourceLocation EndLoc) {
11299   Expr *ValExpr = NumTeams;
11300 
11301   // OpenMP [teams Constrcut, Restrictions]
11302   // The num_teams expression must evaluate to a positive integer value.
11303   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_teams,
11304                                  /*StrictlyPositive=*/true))
11305     return nullptr;
11306 
11307   return new (Context) OMPNumTeamsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11308 }
11309 
ActOnOpenMPThreadLimitClause(Expr * ThreadLimit,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11310 OMPClause *Sema::ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
11311                                               SourceLocation StartLoc,
11312                                               SourceLocation LParenLoc,
11313                                               SourceLocation EndLoc) {
11314   Expr *ValExpr = ThreadLimit;
11315 
11316   // OpenMP [teams Constrcut, Restrictions]
11317   // The thread_limit expression must evaluate to a positive integer value.
11318   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_thread_limit,
11319                                  /*StrictlyPositive=*/true))
11320     return nullptr;
11321 
11322   return new (Context) OMPThreadLimitClause(ValExpr, StartLoc, LParenLoc,
11323                                             EndLoc);
11324 }
11325 
ActOnOpenMPPriorityClause(Expr * Priority,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11326 OMPClause *Sema::ActOnOpenMPPriorityClause(Expr *Priority,
11327                                            SourceLocation StartLoc,
11328                                            SourceLocation LParenLoc,
11329                                            SourceLocation EndLoc) {
11330   Expr *ValExpr = Priority;
11331 
11332   // OpenMP [2.9.1, task Constrcut]
11333   // The priority-value is a non-negative numerical scalar expression.
11334   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_priority,
11335                                  /*StrictlyPositive=*/false))
11336     return nullptr;
11337 
11338   return new (Context) OMPPriorityClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11339 }
11340 
ActOnOpenMPGrainsizeClause(Expr * Grainsize,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11341 OMPClause *Sema::ActOnOpenMPGrainsizeClause(Expr *Grainsize,
11342                                             SourceLocation StartLoc,
11343                                             SourceLocation LParenLoc,
11344                                             SourceLocation EndLoc) {
11345   Expr *ValExpr = Grainsize;
11346 
11347   // OpenMP [2.9.2, taskloop Constrcut]
11348   // The parameter of the grainsize clause must be a positive integer
11349   // expression.
11350   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_grainsize,
11351                                  /*StrictlyPositive=*/true))
11352     return nullptr;
11353 
11354   return new (Context) OMPGrainsizeClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11355 }
11356 
ActOnOpenMPNumTasksClause(Expr * NumTasks,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11357 OMPClause *Sema::ActOnOpenMPNumTasksClause(Expr *NumTasks,
11358                                            SourceLocation StartLoc,
11359                                            SourceLocation LParenLoc,
11360                                            SourceLocation EndLoc) {
11361   Expr *ValExpr = NumTasks;
11362 
11363   // OpenMP [2.9.2, taskloop Constrcut]
11364   // The parameter of the num_tasks clause must be a positive integer
11365   // expression.
11366   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_tasks,
11367                                  /*StrictlyPositive=*/true))
11368     return nullptr;
11369 
11370   return new (Context) OMPNumTasksClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11371 }
11372 
ActOnOpenMPHintClause(Expr * Hint,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11373 OMPClause *Sema::ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
11374                                        SourceLocation LParenLoc,
11375                                        SourceLocation EndLoc) {
11376   // OpenMP [2.13.2, critical construct, Description]
11377   // ... where hint-expression is an integer constant expression that evaluates
11378   // to a valid lock hint.
11379   ExprResult HintExpr = VerifyPositiveIntegerConstantInClause(Hint, OMPC_hint);
11380   if (HintExpr.isInvalid())
11381     return nullptr;
11382   return new (Context)
11383       OMPHintClause(HintExpr.get(), StartLoc, LParenLoc, EndLoc);
11384 }
11385 
ActOnOpenMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,Expr * ChunkSize,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation KindLoc,SourceLocation CommaLoc,SourceLocation EndLoc)11386 OMPClause *Sema::ActOnOpenMPDistScheduleClause(
11387     OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11388     SourceLocation LParenLoc, SourceLocation KindLoc, SourceLocation CommaLoc,
11389     SourceLocation EndLoc) {
11390   if (Kind == OMPC_DIST_SCHEDULE_unknown) {
11391     std::string Values;
11392     Values += "'";
11393     Values += getOpenMPSimpleClauseTypeName(OMPC_dist_schedule, 0);
11394     Values += "'";
11395     Diag(KindLoc, diag::err_omp_unexpected_clause_value)
11396         << Values << getOpenMPClauseName(OMPC_dist_schedule);
11397     return nullptr;
11398   }
11399   Expr *ValExpr = ChunkSize;
11400   Stmt *HelperValStmt = nullptr;
11401   if (ChunkSize) {
11402     if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
11403         !ChunkSize->isInstantiationDependent() &&
11404         !ChunkSize->containsUnexpandedParameterPack()) {
11405       SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
11406       ExprResult Val =
11407           PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
11408       if (Val.isInvalid())
11409         return nullptr;
11410 
11411       ValExpr = Val.get();
11412 
11413       // OpenMP [2.7.1, Restrictions]
11414       //  chunk_size must be a loop invariant integer expression with a positive
11415       //  value.
11416       llvm::APSInt Result;
11417       if (ValExpr->isIntegerConstantExpr(Result, Context)) {
11418         if (Result.isSigned() && !Result.isStrictlyPositive()) {
11419           Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
11420               << "dist_schedule" << ChunkSize->getSourceRange();
11421           return nullptr;
11422         }
11423       } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
11424                  !CurContext->isDependentContext()) {
11425         llvm::MapVector<Expr *, DeclRefExpr *> Captures;
11426         ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
11427         HelperValStmt = buildPreInits(Context, Captures);
11428       }
11429     }
11430   }
11431 
11432   return new (Context)
11433       OMPDistScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc,
11434                             Kind, ValExpr, HelperValStmt);
11435 }
11436 
ActOnOpenMPDefaultmapClause(OpenMPDefaultmapClauseModifier M,OpenMPDefaultmapClauseKind Kind,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation MLoc,SourceLocation KindLoc,SourceLocation EndLoc)11437 OMPClause *Sema::ActOnOpenMPDefaultmapClause(
11438     OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11439     SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11440     SourceLocation KindLoc, SourceLocation EndLoc) {
11441   // OpenMP 4.5 only supports 'defaultmap(tofrom: scalar)'
11442   if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom ||
11443       Kind != OMPC_DEFAULTMAP_scalar) {
11444     std::string Value;
11445     SourceLocation Loc;
11446     Value += "'";
11447     if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom) {
11448       Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
11449                  OMPC_DEFAULTMAP_MODIFIER_tofrom);
11450       Loc = MLoc;
11451     } else {
11452       Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
11453                  OMPC_DEFAULTMAP_scalar);
11454       Loc = KindLoc;
11455     }
11456     Value += "'";
11457     Diag(Loc, diag::err_omp_unexpected_clause_value)
11458         << Value << getOpenMPClauseName(OMPC_defaultmap);
11459     return nullptr;
11460   }
11461 
11462   return new (Context)
11463       OMPDefaultmapClause(StartLoc, LParenLoc, MLoc, KindLoc, EndLoc, Kind, M);
11464 }
11465 
ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc)11466 bool Sema::ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc) {
11467   DeclContext *CurLexicalContext = getCurLexicalContext();
11468   if (!CurLexicalContext->isFileContext() &&
11469       !CurLexicalContext->isExternCContext() &&
11470       !CurLexicalContext->isExternCXXContext()) {
11471     Diag(Loc, diag::err_omp_region_not_file_context);
11472     return false;
11473   }
11474   if (IsInOpenMPDeclareTargetContext) {
11475     Diag(Loc, diag::err_omp_enclosed_declare_target);
11476     return false;
11477   }
11478 
11479   IsInOpenMPDeclareTargetContext = true;
11480   return true;
11481 }
11482 
ActOnFinishOpenMPDeclareTargetDirective()11483 void Sema::ActOnFinishOpenMPDeclareTargetDirective() {
11484   assert(IsInOpenMPDeclareTargetContext &&
11485          "Unexpected ActOnFinishOpenMPDeclareTargetDirective");
11486 
11487   IsInOpenMPDeclareTargetContext = false;
11488 }
11489 
11490 void
ActOnOpenMPDeclareTargetName(Scope * CurScope,CXXScopeSpec & ScopeSpec,const DeclarationNameInfo & Id,OMPDeclareTargetDeclAttr::MapTypeTy MT,NamedDeclSetType & SameDirectiveDecls)11491 Sema::ActOnOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec,
11492                                    const DeclarationNameInfo &Id,
11493                                    OMPDeclareTargetDeclAttr::MapTypeTy MT,
11494                                    NamedDeclSetType &SameDirectiveDecls) {
11495   LookupResult Lookup(*this, Id, LookupOrdinaryName);
11496   LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
11497 
11498   if (Lookup.isAmbiguous())
11499     return;
11500   Lookup.suppressDiagnostics();
11501 
11502   if (!Lookup.isSingleResult()) {
11503     if (TypoCorrection Corrected =
11504             CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr,
11505                         llvm::make_unique<VarOrFuncDeclFilterCCC>(*this),
11506                         CTK_ErrorRecovery)) {
11507       diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
11508                                   << Id.getName());
11509       checkDeclIsAllowedInOpenMPTarget(nullptr, Corrected.getCorrectionDecl());
11510       return;
11511     }
11512 
11513     Diag(Id.getLoc(), diag::err_undeclared_var_use) << Id.getName();
11514     return;
11515   }
11516 
11517   NamedDecl *ND = Lookup.getAsSingle<NamedDecl>();
11518   if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
11519     if (!SameDirectiveDecls.insert(cast<NamedDecl>(ND->getCanonicalDecl())))
11520       Diag(Id.getLoc(), diag::err_omp_declare_target_multiple) << Id.getName();
11521 
11522     if (!ND->hasAttr<OMPDeclareTargetDeclAttr>()) {
11523       Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(Context, MT);
11524       ND->addAttr(A);
11525       if (ASTMutationListener *ML = Context.getASTMutationListener())
11526         ML->DeclarationMarkedOpenMPDeclareTarget(ND, A);
11527       checkDeclIsAllowedInOpenMPTarget(nullptr, ND);
11528     } else if (ND->getAttr<OMPDeclareTargetDeclAttr>()->getMapType() != MT) {
11529       Diag(Id.getLoc(), diag::err_omp_declare_target_to_and_link)
11530           << Id.getName();
11531     }
11532   } else
11533     Diag(Id.getLoc(), diag::err_omp_invalid_target_decl) << Id.getName();
11534 }
11535 
checkDeclInTargetContext(SourceLocation SL,SourceRange SR,Sema & SemaRef,Decl * D)11536 static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR,
11537                                      Sema &SemaRef, Decl *D) {
11538   if (!D)
11539     return;
11540   Decl *LD = nullptr;
11541   if (isa<TagDecl>(D)) {
11542     LD = cast<TagDecl>(D)->getDefinition();
11543   } else if (isa<VarDecl>(D)) {
11544     LD = cast<VarDecl>(D)->getDefinition();
11545 
11546     // If this is an implicit variable that is legal and we do not need to do
11547     // anything.
11548     if (cast<VarDecl>(D)->isImplicit()) {
11549       Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11550           SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11551       D->addAttr(A);
11552       if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11553         ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11554       return;
11555     }
11556 
11557   } else if (isa<FunctionDecl>(D)) {
11558     const FunctionDecl *FD = nullptr;
11559     if (cast<FunctionDecl>(D)->hasBody(FD))
11560       LD = const_cast<FunctionDecl *>(FD);
11561 
11562     // If the definition is associated with the current declaration in the
11563     // target region (it can be e.g. a lambda) that is legal and we do not need
11564     // to do anything else.
11565     if (LD == D) {
11566       Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11567           SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11568       D->addAttr(A);
11569       if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11570         ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11571       return;
11572     }
11573   }
11574   if (!LD)
11575     LD = D;
11576   if (LD && !LD->hasAttr<OMPDeclareTargetDeclAttr>() &&
11577       (isa<VarDecl>(LD) || isa<FunctionDecl>(LD))) {
11578     // Outlined declaration is not declared target.
11579     if (LD->isOutOfLine()) {
11580       SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
11581       SemaRef.Diag(SL, diag::note_used_here) << SR;
11582     } else {
11583       DeclContext *DC = LD->getDeclContext();
11584       while (DC) {
11585         if (isa<FunctionDecl>(DC) &&
11586             cast<FunctionDecl>(DC)->hasAttr<OMPDeclareTargetDeclAttr>())
11587           break;
11588         DC = DC->getParent();
11589       }
11590       if (DC)
11591         return;
11592 
11593       // Is not declared in target context.
11594       SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
11595       SemaRef.Diag(SL, diag::note_used_here) << SR;
11596     }
11597     // Mark decl as declared target to prevent further diagnostic.
11598     Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11599         SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11600     D->addAttr(A);
11601     if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11602       ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11603   }
11604 }
11605 
checkValueDeclInTarget(SourceLocation SL,SourceRange SR,Sema & SemaRef,DSAStackTy * Stack,ValueDecl * VD)11606 static bool checkValueDeclInTarget(SourceLocation SL, SourceRange SR,
11607                                    Sema &SemaRef, DSAStackTy *Stack,
11608                                    ValueDecl *VD) {
11609   if (VD->hasAttr<OMPDeclareTargetDeclAttr>())
11610     return true;
11611   if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType()))
11612     return false;
11613   return true;
11614 }
11615 
checkDeclIsAllowedInOpenMPTarget(Expr * E,Decl * D)11616 void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) {
11617   if (!D || D->isInvalidDecl())
11618     return;
11619   SourceRange SR = E ? E->getSourceRange() : D->getSourceRange();
11620   SourceLocation SL = E ? E->getLocStart() : D->getLocation();
11621   // 2.10.6: threadprivate variable cannot appear in a declare target directive.
11622   if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
11623     if (DSAStack->isThreadPrivate(VD)) {
11624       Diag(SL, diag::err_omp_threadprivate_in_target);
11625       ReportOriginalDSA(*this, DSAStack, VD, DSAStack->getTopDSA(VD, false));
11626       return;
11627     }
11628   }
11629   if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
11630     // Problem if any with var declared with incomplete type will be reported
11631     // as normal, so no need to check it here.
11632     if ((E || !VD->getType()->isIncompleteType()) &&
11633         !checkValueDeclInTarget(SL, SR, *this, DSAStack, VD)) {
11634       // Mark decl as declared target to prevent further diagnostic.
11635       if (isa<VarDecl>(VD) || isa<FunctionDecl>(VD)) {
11636         Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11637             Context, OMPDeclareTargetDeclAttr::MT_To);
11638         VD->addAttr(A);
11639         if (ASTMutationListener *ML = Context.getASTMutationListener())
11640           ML->DeclarationMarkedOpenMPDeclareTarget(VD, A);
11641       }
11642       return;
11643     }
11644   }
11645   if (!E) {
11646     // Checking declaration inside declare target region.
11647     if (!D->hasAttr<OMPDeclareTargetDeclAttr>() &&
11648         (isa<VarDecl>(D) || isa<FunctionDecl>(D))) {
11649       Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11650           Context, OMPDeclareTargetDeclAttr::MT_To);
11651       D->addAttr(A);
11652       if (ASTMutationListener *ML = Context.getASTMutationListener())
11653         ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11654     }
11655     return;
11656   }
11657   checkDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this, D);
11658 }
11659 
ActOnOpenMPToClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11660 OMPClause *Sema::ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
11661                                      SourceLocation StartLoc,
11662                                      SourceLocation LParenLoc,
11663                                      SourceLocation EndLoc) {
11664   MappableVarListInfo MVLI(VarList);
11665   checkMappableExpressionList(*this, DSAStack, OMPC_to, MVLI, StartLoc);
11666   if (MVLI.ProcessedVarList.empty())
11667     return nullptr;
11668 
11669   return OMPToClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11670                              MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11671                              MVLI.VarComponents);
11672 }
11673 
ActOnOpenMPFromClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11674 OMPClause *Sema::ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
11675                                        SourceLocation StartLoc,
11676                                        SourceLocation LParenLoc,
11677                                        SourceLocation EndLoc) {
11678   MappableVarListInfo MVLI(VarList);
11679   checkMappableExpressionList(*this, DSAStack, OMPC_from, MVLI, StartLoc);
11680   if (MVLI.ProcessedVarList.empty())
11681     return nullptr;
11682 
11683   return OMPFromClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11684                                MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11685                                MVLI.VarComponents);
11686 }
11687 
ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11688 OMPClause *Sema::ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
11689                                                SourceLocation StartLoc,
11690                                                SourceLocation LParenLoc,
11691                                                SourceLocation EndLoc) {
11692   SmallVector<Expr *, 8> Vars;
11693   for (auto &RefExpr : VarList) {
11694     assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause.");
11695     SourceLocation ELoc;
11696     SourceRange ERange;
11697     Expr *SimpleRefExpr = RefExpr;
11698     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11699     if (Res.second) {
11700       // It will be analyzed later.
11701       Vars.push_back(RefExpr);
11702     }
11703     ValueDecl *D = Res.first;
11704     if (!D)
11705       continue;
11706 
11707     QualType Type = D->getType();
11708     // item should be a pointer or reference to pointer
11709     if (!Type.getNonReferenceType()->isPointerType()) {
11710       Diag(ELoc, diag::err_omp_usedeviceptr_not_a_pointer)
11711           << 0 << RefExpr->getSourceRange();
11712       continue;
11713     }
11714     Vars.push_back(RefExpr->IgnoreParens());
11715   }
11716 
11717   if (Vars.empty())
11718     return nullptr;
11719 
11720   return OMPUseDevicePtrClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11721                                        Vars);
11722 }
11723 
ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr * > VarList,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)11724 OMPClause *Sema::ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11725                                               SourceLocation StartLoc,
11726                                               SourceLocation LParenLoc,
11727                                               SourceLocation EndLoc) {
11728   SmallVector<Expr *, 8> Vars;
11729   for (auto &RefExpr : VarList) {
11730     assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause.");
11731     SourceLocation ELoc;
11732     SourceRange ERange;
11733     Expr *SimpleRefExpr = RefExpr;
11734     auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11735     if (Res.second) {
11736       // It will be analyzed later.
11737       Vars.push_back(RefExpr);
11738     }
11739     ValueDecl *D = Res.first;
11740     if (!D)
11741       continue;
11742 
11743     QualType Type = D->getType();
11744     // item should be a pointer or array or reference to pointer or array
11745     if (!Type.getNonReferenceType()->isPointerType() &&
11746         !Type.getNonReferenceType()->isArrayType()) {
11747       Diag(ELoc, diag::err_omp_argument_type_isdeviceptr)
11748           << 0 << RefExpr->getSourceRange();
11749       continue;
11750     }
11751     Vars.push_back(RefExpr->IgnoreParens());
11752   }
11753 
11754   if (Vars.empty())
11755     return nullptr;
11756 
11757   return OMPIsDevicePtrClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11758                                       Vars);
11759 }
11760