67a8ac95377d453048b8f17c8343a65a271bb9c4
[lldb.git] / clang / lib / Sema / SemaOpenMP.cpp
1 //===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 /// This file implements semantic analysis for OpenMP directives and
10 /// clauses.
11 ///
12 //===----------------------------------------------------------------------===//
13
14 #include "TreeTransform.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTMutationListener.h"
17 #include "clang/AST/CXXInheritance.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclOpenMP.h"
21 #include "clang/AST/OpenMPClause.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/DiagnosticSema.h"
27 #include "clang/Basic/OpenMPKinds.h"
28 #include "clang/Basic/PartialDiagnostic.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Sema/Initialization.h"
31 #include "clang/Sema/Lookup.h"
32 #include "clang/Sema/Scope.h"
33 #include "clang/Sema/ScopeInfo.h"
34 #include "clang/Sema/SemaInternal.h"
35 #include "llvm/ADT/IndexedMap.h"
36 #include "llvm/ADT/PointerEmbeddedInt.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/Frontend/OpenMP/OMPConstants.h"
40 #include <set>
41
42 using namespace clang;
43 using namespace llvm::omp;
44
45 //===----------------------------------------------------------------------===//
46 // Stack of data-sharing attributes for variables
47 //===----------------------------------------------------------------------===//
48
49 static const Expr *checkMapClauseExpressionBase(
50     Sema &SemaRef, Expr *E,
51     OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents,
52     OpenMPClauseKind CKind, OpenMPDirectiveKind DKind, bool NoDiagnose);
53
54 namespace {
55 /// Default data sharing attributes, which can be applied to directive.
56 enum DefaultDataSharingAttributes {
57   DSA_unspecified = 0,       /// Data sharing attribute not specified.
58   DSA_none = 1 << 0,         /// Default data sharing attribute 'none'.
59   DSA_shared = 1 << 1,       /// Default data sharing attribute 'shared'.
60   DSA_firstprivate = 1 << 2, /// Default data sharing attribute 'firstprivate'.
61 };
62
63 /// Stack for tracking declarations used in OpenMP directives and
64 /// clauses and their data-sharing attributes.
65 class DSAStackTy {
66 public:
67   struct DSAVarData {
68     OpenMPDirectiveKind DKind = OMPD_unknown;
69     OpenMPClauseKind CKind = OMPC_unknown;
70     unsigned Modifier = 0;
71     const Expr *RefExpr = nullptr;
72     DeclRefExpr *PrivateCopy = nullptr;
73     SourceLocation ImplicitDSALoc;
74     bool AppliedToPointee = false;
75     DSAVarData() = default;
76     DSAVarData(OpenMPDirectiveKind DKind, OpenMPClauseKind CKind,
77                const Expr *RefExpr, DeclRefExpr *PrivateCopy,
78                SourceLocation ImplicitDSALoc, unsigned Modifier,
79                bool AppliedToPointee)
80         : DKind(DKind), CKind(CKind), Modifier(Modifier), RefExpr(RefExpr),
81           PrivateCopy(PrivateCopy), ImplicitDSALoc(ImplicitDSALoc),
82           AppliedToPointee(AppliedToPointee) {}
83   };
84   using OperatorOffsetTy =
85       llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4>;
86   using DoacrossDependMapTy =
87       llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>;
88   /// Kind of the declaration used in the uses_allocators clauses.
89   enum class UsesAllocatorsDeclKind {
90     /// Predefined allocator
91     PredefinedAllocator,
92     /// User-defined allocator
93     UserDefinedAllocator,
94     /// The declaration that represent allocator trait
95     AllocatorTrait,
96   };
97
98 private:
99   struct DSAInfo {
100     OpenMPClauseKind Attributes = OMPC_unknown;
101     unsigned Modifier = 0;
102     /// Pointer to a reference expression and a flag which shows that the
103     /// variable is marked as lastprivate(true) or not (false).
104     llvm::PointerIntPair<const Expr *, 1, bool> RefExpr;
105     DeclRefExpr *PrivateCopy = nullptr;
106     /// true if the attribute is applied to the pointee, not the variable
107     /// itself.
108     bool AppliedToPointee = false;
109   };
110   using DeclSAMapTy = llvm::SmallDenseMap<const ValueDecl *, DSAInfo, 8>;
111   using UsedRefMapTy = llvm::SmallDenseMap<const ValueDecl *, const Expr *, 8>;
112   using LCDeclInfo = std::pair<unsigned, VarDecl *>;
113   using LoopControlVariablesMapTy =
114       llvm::SmallDenseMap<const ValueDecl *, LCDeclInfo, 8>;
115   /// Struct that associates a component with the clause kind where they are
116   /// found.
117   struct MappedExprComponentTy {
118     OMPClauseMappableExprCommon::MappableExprComponentLists Components;
119     OpenMPClauseKind Kind = OMPC_unknown;
120   };
121   using MappedExprComponentsTy =
122       llvm::DenseMap<const ValueDecl *, MappedExprComponentTy>;
123   using CriticalsWithHintsTy =
124       llvm::StringMap<std::pair<const OMPCriticalDirective *, llvm::APSInt>>;
125   struct ReductionData {
126     using BOKPtrType = llvm::PointerEmbeddedInt<BinaryOperatorKind, 16>;
127     SourceRange ReductionRange;
128     llvm::PointerUnion<const Expr *, BOKPtrType> ReductionOp;
129     ReductionData() = default;
130     void set(BinaryOperatorKind BO, SourceRange RR) {
131       ReductionRange = RR;
132       ReductionOp = BO;
133     }
134     void set(const Expr *RefExpr, SourceRange RR) {
135       ReductionRange = RR;
136       ReductionOp = RefExpr;
137     }
138   };
139   using DeclReductionMapTy =
140       llvm::SmallDenseMap<const ValueDecl *, ReductionData, 4>;
141   struct DefaultmapInfo {
142     OpenMPDefaultmapClauseModifier ImplicitBehavior =
143         OMPC_DEFAULTMAP_MODIFIER_unknown;
144     SourceLocation SLoc;
145     DefaultmapInfo() = default;
146     DefaultmapInfo(OpenMPDefaultmapClauseModifier M, SourceLocation Loc)
147         : ImplicitBehavior(M), SLoc(Loc) {}
148   };
149
150   struct SharingMapTy {
151     DeclSAMapTy SharingMap;
152     DeclReductionMapTy ReductionMap;
153     UsedRefMapTy AlignedMap;
154     UsedRefMapTy NontemporalMap;
155     MappedExprComponentsTy MappedExprComponents;
156     LoopControlVariablesMapTy LCVMap;
157     DefaultDataSharingAttributes DefaultAttr = DSA_unspecified;
158     SourceLocation DefaultAttrLoc;
159     DefaultmapInfo DefaultmapMap[OMPC_DEFAULTMAP_unknown];
160     OpenMPDirectiveKind Directive = OMPD_unknown;
161     DeclarationNameInfo DirectiveName;
162     Scope *CurScope = nullptr;
163     DeclContext *Context = nullptr;
164     SourceLocation ConstructLoc;
165     /// Set of 'depend' clauses with 'sink|source' dependence kind. Required to
166     /// get the data (loop counters etc.) about enclosing loop-based construct.
167     /// This data is required during codegen.
168     DoacrossDependMapTy DoacrossDepends;
169     /// First argument (Expr *) contains optional argument of the
170     /// 'ordered' clause, the second one is true if the regions has 'ordered'
171     /// clause, false otherwise.
172     llvm::Optional<std::pair<const Expr *, OMPOrderedClause *>> OrderedRegion;
173     unsigned AssociatedLoops = 1;
174     bool HasMutipleLoops = false;
175     const Decl *PossiblyLoopCounter = nullptr;
176     bool NowaitRegion = false;
177     bool CancelRegion = false;
178     bool LoopStart = false;
179     bool BodyComplete = false;
180     SourceLocation PrevScanLocation;
181     SourceLocation PrevOrderedLocation;
182     SourceLocation InnerTeamsRegionLoc;
183     /// Reference to the taskgroup task_reduction reference expression.
184     Expr *TaskgroupReductionRef = nullptr;
185     llvm::DenseSet<QualType> MappedClassesQualTypes;
186     SmallVector<Expr *, 4> InnerUsedAllocators;
187     llvm::DenseSet<CanonicalDeclPtr<Decl>> ImplicitTaskFirstprivates;
188     /// List of globals marked as declare target link in this target region
189     /// (isOpenMPTargetExecutionDirective(Directive) == true).
190     llvm::SmallVector<DeclRefExpr *, 4> DeclareTargetLinkVarDecls;
191     /// List of decls used in inclusive/exclusive clauses of the scan directive.
192     llvm::DenseSet<CanonicalDeclPtr<Decl>> UsedInScanDirective;
193     llvm::DenseMap<CanonicalDeclPtr<const Decl>, UsesAllocatorsDeclKind>
194         UsesAllocatorsDecls;
195     Expr *DeclareMapperVar = nullptr;
196     SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name,
197                  Scope *CurScope, SourceLocation Loc)
198         : Directive(DKind), DirectiveName(Name), CurScope(CurScope),
199           ConstructLoc(Loc) {}
200     SharingMapTy() = default;
201   };
202
203   using StackTy = SmallVector<SharingMapTy, 4>;
204
205   /// Stack of used declaration and their data-sharing attributes.
206   DeclSAMapTy Threadprivates;
207   const FunctionScopeInfo *CurrentNonCapturingFunctionScope = nullptr;
208   SmallVector<std::pair<StackTy, const FunctionScopeInfo *>, 4> Stack;
209   /// true, if check for DSA must be from parent directive, false, if
210   /// from current directive.
211   OpenMPClauseKind ClauseKindMode = OMPC_unknown;
212   Sema &SemaRef;
213   bool ForceCapturing = false;
214   /// true if all the variables in the target executable directives must be
215   /// captured by reference.
216   bool ForceCaptureByReferenceInTargetExecutable = false;
217   CriticalsWithHintsTy Criticals;
218   unsigned IgnoredStackElements = 0;
219
220   /// Iterators over the stack iterate in order from innermost to outermost
221   /// directive.
222   using const_iterator = StackTy::const_reverse_iterator;
223   const_iterator begin() const {
224     return Stack.empty() ? const_iterator()
225                          : Stack.back().first.rbegin() + IgnoredStackElements;
226   }
227   const_iterator end() const {
228     return Stack.empty() ? const_iterator() : Stack.back().first.rend();
229   }
230   using iterator = StackTy::reverse_iterator;
231   iterator begin() {
232     return Stack.empty() ? iterator()
233                          : Stack.back().first.rbegin() + IgnoredStackElements;
234   }
235   iterator end() {
236     return Stack.empty() ? iterator() : Stack.back().first.rend();
237   }
238
239   // Convenience operations to get at the elements of the stack.
240
241   bool isStackEmpty() const {
242     return Stack.empty() ||
243            Stack.back().second != CurrentNonCapturingFunctionScope ||
244            Stack.back().first.size() <= IgnoredStackElements;
245   }
246   size_t getStackSize() const {
247     return isStackEmpty() ? 0
248                           : Stack.back().first.size() - IgnoredStackElements;
249   }
250
251   SharingMapTy *getTopOfStackOrNull() {
252     size_t Size = getStackSize();
253     if (Size == 0)
254       return nullptr;
255     return &Stack.back().first[Size - 1];
256   }
257   const SharingMapTy *getTopOfStackOrNull() const {
258     return const_cast<DSAStackTy&>(*this).getTopOfStackOrNull();
259   }
260   SharingMapTy &getTopOfStack() {
261     assert(!isStackEmpty() && "no current directive");
262     return *getTopOfStackOrNull();
263   }
264   const SharingMapTy &getTopOfStack() const {
265     return const_cast<DSAStackTy&>(*this).getTopOfStack();
266   }
267
268   SharingMapTy *getSecondOnStackOrNull() {
269     size_t Size = getStackSize();
270     if (Size <= 1)
271       return nullptr;
272     return &Stack.back().first[Size - 2];
273   }
274   const SharingMapTy *getSecondOnStackOrNull() const {
275     return const_cast<DSAStackTy&>(*this).getSecondOnStackOrNull();
276   }
277
278   /// Get the stack element at a certain level (previously returned by
279   /// \c getNestingLevel).
280   ///
281   /// Note that nesting levels count from outermost to innermost, and this is
282   /// the reverse of our iteration order where new inner levels are pushed at
283   /// the front of the stack.
284   SharingMapTy &getStackElemAtLevel(unsigned Level) {
285     assert(Level < getStackSize() && "no such stack element");
286     return Stack.back().first[Level];
287   }
288   const SharingMapTy &getStackElemAtLevel(unsigned Level) const {
289     return const_cast<DSAStackTy&>(*this).getStackElemAtLevel(Level);
290   }
291
292   DSAVarData getDSA(const_iterator &Iter, ValueDecl *D) const;
293
294   /// Checks if the variable is a local for OpenMP region.
295   bool isOpenMPLocal(VarDecl *D, const_iterator Iter) const;
296
297   /// Vector of previously declared requires directives
298   SmallVector<const OMPRequiresDecl *, 2> RequiresDecls;
299   /// omp_allocator_handle_t type.
300   QualType OMPAllocatorHandleT;
301   /// omp_depend_t type.
302   QualType OMPDependT;
303   /// omp_event_handle_t type.
304   QualType OMPEventHandleT;
305   /// omp_alloctrait_t type.
306   QualType OMPAlloctraitT;
307   /// Expression for the predefined allocators.
308   Expr *OMPPredefinedAllocators[OMPAllocateDeclAttr::OMPUserDefinedMemAlloc] = {
309       nullptr};
310   /// Vector of previously encountered target directives
311   SmallVector<SourceLocation, 2> TargetLocations;
312   SourceLocation AtomicLocation;
313
314 public:
315   explicit DSAStackTy(Sema &S) : SemaRef(S) {}
316
317   /// Sets omp_allocator_handle_t type.
318   void setOMPAllocatorHandleT(QualType Ty) { OMPAllocatorHandleT = Ty; }
319   /// Gets omp_allocator_handle_t type.
320   QualType getOMPAllocatorHandleT() const { return OMPAllocatorHandleT; }
321   /// Sets omp_alloctrait_t type.
322   void setOMPAlloctraitT(QualType Ty) { OMPAlloctraitT = Ty; }
323   /// Gets omp_alloctrait_t type.
324   QualType getOMPAlloctraitT() const { return OMPAlloctraitT; }
325   /// Sets the given default allocator.
326   void setAllocator(OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind,
327                     Expr *Allocator) {
328     OMPPredefinedAllocators[AllocatorKind] = Allocator;
329   }
330   /// Returns the specified default allocator.
331   Expr *getAllocator(OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind) const {
332     return OMPPredefinedAllocators[AllocatorKind];
333   }
334   /// Sets omp_depend_t type.
335   void setOMPDependT(QualType Ty) { OMPDependT = Ty; }
336   /// Gets omp_depend_t type.
337   QualType getOMPDependT() const { return OMPDependT; }
338
339   /// Sets omp_event_handle_t type.
340   void setOMPEventHandleT(QualType Ty) { OMPEventHandleT = Ty; }
341   /// Gets omp_event_handle_t type.
342   QualType getOMPEventHandleT() const { return OMPEventHandleT; }
343
344   bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
345   OpenMPClauseKind getClauseParsingMode() const {
346     assert(isClauseParsingMode() && "Must be in clause parsing mode.");
347     return ClauseKindMode;
348   }
349   void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }
350
351   bool isBodyComplete() const {
352     const SharingMapTy *Top = getTopOfStackOrNull();
353     return Top && Top->BodyComplete;
354   }
355   void setBodyComplete() {
356     getTopOfStack().BodyComplete = true;
357   }
358
359   bool isForceVarCapturing() const { return ForceCapturing; }
360   void setForceVarCapturing(bool V) { ForceCapturing = V; }
361
362   void setForceCaptureByReferenceInTargetExecutable(bool V) {
363     ForceCaptureByReferenceInTargetExecutable = V;
364   }
365   bool isForceCaptureByReferenceInTargetExecutable() const {
366     return ForceCaptureByReferenceInTargetExecutable;
367   }
368
369   void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
370             Scope *CurScope, SourceLocation Loc) {
371     assert(!IgnoredStackElements &&
372            "cannot change stack while ignoring elements");
373     if (Stack.empty() ||
374         Stack.back().second != CurrentNonCapturingFunctionScope)
375       Stack.emplace_back(StackTy(), CurrentNonCapturingFunctionScope);
376     Stack.back().first.emplace_back(DKind, DirName, CurScope, Loc);
377     Stack.back().first.back().DefaultAttrLoc = Loc;
378   }
379
380   void pop() {
381     assert(!IgnoredStackElements &&
382            "cannot change stack while ignoring elements");
383     assert(!Stack.back().first.empty() &&
384            "Data-sharing attributes stack is empty!");
385     Stack.back().first.pop_back();
386   }
387
388   /// RAII object to temporarily leave the scope of a directive when we want to
389   /// logically operate in its parent.
390   class ParentDirectiveScope {
391     DSAStackTy &Self;
392     bool Active;
393   public:
394     ParentDirectiveScope(DSAStackTy &Self, bool Activate)
395         : Self(Self), Active(false) {
396       if (Activate)
397         enable();
398     }
399     ~ParentDirectiveScope() { disable(); }
400     void disable() {
401       if (Active) {
402         --Self.IgnoredStackElements;
403         Active = false;
404       }
405     }
406     void enable() {
407       if (!Active) {
408         ++Self.IgnoredStackElements;
409         Active = true;
410       }
411     }
412   };
413
414   /// Marks that we're started loop parsing.
415   void loopInit() {
416     assert(isOpenMPLoopDirective(getCurrentDirective()) &&
417            "Expected loop-based directive.");
418     getTopOfStack().LoopStart = true;
419   }
420   /// Start capturing of the variables in the loop context.
421   void loopStart() {
422     assert(isOpenMPLoopDirective(getCurrentDirective()) &&
423            "Expected loop-based directive.");
424     getTopOfStack().LoopStart = false;
425   }
426   /// true, if variables are captured, false otherwise.
427   bool isLoopStarted() const {
428     assert(isOpenMPLoopDirective(getCurrentDirective()) &&
429            "Expected loop-based directive.");
430     return !getTopOfStack().LoopStart;
431   }
432   /// Marks (or clears) declaration as possibly loop counter.
433   void resetPossibleLoopCounter(const Decl *D = nullptr) {
434     getTopOfStack().PossiblyLoopCounter =
435         D ? D->getCanonicalDecl() : D;
436   }
437   /// Gets the possible loop counter decl.
438   const Decl *getPossiblyLoopCunter() const {
439     return getTopOfStack().PossiblyLoopCounter;
440   }
441   /// Start new OpenMP region stack in new non-capturing function.
442   void pushFunction() {
443     assert(!IgnoredStackElements &&
444            "cannot change stack while ignoring elements");
445     const FunctionScopeInfo *CurFnScope = SemaRef.getCurFunction();
446     assert(!isa<CapturingScopeInfo>(CurFnScope));
447     CurrentNonCapturingFunctionScope = CurFnScope;
448   }
449   /// Pop region stack for non-capturing function.
450   void popFunction(const FunctionScopeInfo *OldFSI) {
451     assert(!IgnoredStackElements &&
452            "cannot change stack while ignoring elements");
453     if (!Stack.empty() && Stack.back().second == OldFSI) {
454       assert(Stack.back().first.empty());
455       Stack.pop_back();
456     }
457     CurrentNonCapturingFunctionScope = nullptr;
458     for (const FunctionScopeInfo *FSI : llvm::reverse(SemaRef.FunctionScopes)) {
459       if (!isa<CapturingScopeInfo>(FSI)) {
460         CurrentNonCapturingFunctionScope = FSI;
461         break;
462       }
463     }
464   }
465
466   void addCriticalWithHint(const OMPCriticalDirective *D, llvm::APSInt Hint) {
467     Criticals.try_emplace(D->getDirectiveName().getAsString(), D, Hint);
468   }
469   const std::pair<const OMPCriticalDirective *, llvm::APSInt>
470   getCriticalWithHint(const DeclarationNameInfo &Name) const {
471     auto I = Criticals.find(Name.getAsString());
472     if (I != Criticals.end())
473       return I->second;
474     return std::make_pair(nullptr, llvm::APSInt());
475   }
476   /// If 'aligned' declaration for given variable \a D was not seen yet,
477   /// add it and return NULL; otherwise return previous occurrence's expression
478   /// for diagnostics.
479   const Expr *addUniqueAligned(const ValueDecl *D, const Expr *NewDE);
480   /// If 'nontemporal' declaration for given variable \a D was not seen yet,
481   /// add it and return NULL; otherwise return previous occurrence's expression
482   /// for diagnostics.
483   const Expr *addUniqueNontemporal(const ValueDecl *D, const Expr *NewDE);
484
485   /// Register specified variable as loop control variable.
486   void addLoopControlVariable(const ValueDecl *D, VarDecl *Capture);
487   /// Check if the specified variable is a loop control variable for
488   /// current region.
489   /// \return The index of the loop control variable in the list of associated
490   /// for-loops (from outer to inner).
491   const LCDeclInfo isLoopControlVariable(const ValueDecl *D) const;
492   /// Check if the specified variable is a loop control variable for
493   /// parent region.
494   /// \return The index of the loop control variable in the list of associated
495   /// for-loops (from outer to inner).
496   const LCDeclInfo isParentLoopControlVariable(const ValueDecl *D) const;
497   /// Check if the specified variable is a loop control variable for
498   /// current region.
499   /// \return The index of the loop control variable in the list of associated
500   /// for-loops (from outer to inner).
501   const LCDeclInfo isLoopControlVariable(const ValueDecl *D,
502                                          unsigned Level) const;
503   /// Get the loop control variable for the I-th loop (or nullptr) in
504   /// parent directive.
505   const ValueDecl *getParentLoopControlVariable(unsigned I) const;
506
507   /// Marks the specified decl \p D as used in scan directive.
508   void markDeclAsUsedInScanDirective(ValueDecl *D) {
509     if (SharingMapTy *Stack = getSecondOnStackOrNull())
510       Stack->UsedInScanDirective.insert(D);
511   }
512
513   /// Checks if the specified declaration was used in the inner scan directive.
514   bool isUsedInScanDirective(ValueDecl *D) const {
515     if (const SharingMapTy *Stack = getTopOfStackOrNull())
516       return Stack->UsedInScanDirective.count(D) > 0;
517     return false;
518   }
519
520   /// Adds explicit data sharing attribute to the specified declaration.
521   void addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A,
522               DeclRefExpr *PrivateCopy = nullptr, unsigned Modifier = 0,
523               bool AppliedToPointee = false);
524
525   /// Adds additional information for the reduction items with the reduction id
526   /// represented as an operator.
527   void addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
528                                  BinaryOperatorKind BOK);
529   /// Adds additional information for the reduction items with the reduction id
530   /// represented as reduction identifier.
531   void addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
532                                  const Expr *ReductionRef);
533   /// Returns the location and reduction operation from the innermost parent
534   /// region for the given \p D.
535   const DSAVarData
536   getTopMostTaskgroupReductionData(const ValueDecl *D, SourceRange &SR,
537                                    BinaryOperatorKind &BOK,
538                                    Expr *&TaskgroupDescriptor) const;
539   /// Returns the location and reduction operation from the innermost parent
540   /// region for the given \p D.
541   const DSAVarData
542   getTopMostTaskgroupReductionData(const ValueDecl *D, SourceRange &SR,
543                                    const Expr *&ReductionRef,
544                                    Expr *&TaskgroupDescriptor) const;
545   /// Return reduction reference expression for the current taskgroup or
546   /// parallel/worksharing directives with task reductions.
547   Expr *getTaskgroupReductionRef() const {
548     assert((getTopOfStack().Directive == OMPD_taskgroup ||
549             ((isOpenMPParallelDirective(getTopOfStack().Directive) ||
550               isOpenMPWorksharingDirective(getTopOfStack().Directive)) &&
551              !isOpenMPSimdDirective(getTopOfStack().Directive))) &&
552            "taskgroup reference expression requested for non taskgroup or "
553            "parallel/worksharing directive.");
554     return getTopOfStack().TaskgroupReductionRef;
555   }
556   /// Checks if the given \p VD declaration is actually a taskgroup reduction
557   /// descriptor variable at the \p Level of OpenMP regions.
558   bool isTaskgroupReductionRef(const ValueDecl *VD, unsigned Level) const {
559     return getStackElemAtLevel(Level).TaskgroupReductionRef &&
560            cast<DeclRefExpr>(getStackElemAtLevel(Level).TaskgroupReductionRef)
561                    ->getDecl() == VD;
562   }
563
564   /// Returns data sharing attributes from top of the stack for the
565   /// specified declaration.
566   const DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
567   /// Returns data-sharing attributes for the specified declaration.
568   const DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent) const;
569   /// Returns data-sharing attributes for the specified declaration.
570   const DSAVarData getImplicitDSA(ValueDecl *D, unsigned Level) const;
571   /// Checks if the specified variables has data-sharing attributes which
572   /// match specified \a CPred predicate in any directive which matches \a DPred
573   /// predicate.
574   const DSAVarData
575   hasDSA(ValueDecl *D,
576          const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
577          const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
578          bool FromParent) const;
579   /// Checks if the specified variables has data-sharing attributes which
580   /// match specified \a CPred predicate in any innermost directive which
581   /// matches \a DPred predicate.
582   const DSAVarData
583   hasInnermostDSA(ValueDecl *D,
584                   const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
585                   const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
586                   bool FromParent) const;
587   /// Checks if the specified variables has explicit data-sharing
588   /// attributes which match specified \a CPred predicate at the specified
589   /// OpenMP region.
590   bool
591   hasExplicitDSA(const ValueDecl *D,
592                  const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
593                  unsigned Level, bool NotLastprivate = false) const;
594
595   /// Returns true if the directive at level \Level matches in the
596   /// specified \a DPred predicate.
597   bool hasExplicitDirective(
598       const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
599       unsigned Level) const;
600
601   /// Finds a directive which matches specified \a DPred predicate.
602   bool hasDirective(
603       const llvm::function_ref<bool(
604           OpenMPDirectiveKind, const DeclarationNameInfo &, SourceLocation)>
605           DPred,
606       bool FromParent) const;
607
608   /// Returns currently analyzed directive.
609   OpenMPDirectiveKind getCurrentDirective() const {
610     const SharingMapTy *Top = getTopOfStackOrNull();
611     return Top ? Top->Directive : OMPD_unknown;
612   }
613   /// Returns directive kind at specified level.
614   OpenMPDirectiveKind getDirective(unsigned Level) const {
615     assert(!isStackEmpty() && "No directive at specified level.");
616     return getStackElemAtLevel(Level).Directive;
617   }
618   /// Returns the capture region at the specified level.
619   OpenMPDirectiveKind getCaptureRegion(unsigned Level,
620                                        unsigned OpenMPCaptureLevel) const {
621     SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
622     getOpenMPCaptureRegions(CaptureRegions, getDirective(Level));
623     return CaptureRegions[OpenMPCaptureLevel];
624   }
625   /// Returns parent directive.
626   OpenMPDirectiveKind getParentDirective() const {
627     const SharingMapTy *Parent = getSecondOnStackOrNull();
628     return Parent ? Parent->Directive : OMPD_unknown;
629   }
630
631   /// Add requires decl to internal vector
632   void addRequiresDecl(OMPRequiresDecl *RD) {
633     RequiresDecls.push_back(RD);
634   }
635
636   /// Checks if the defined 'requires' directive has specified type of clause.
637   template <typename ClauseType>
638   bool hasRequiresDeclWithClause() const {
639     return llvm::any_of(RequiresDecls, [](const OMPRequiresDecl *D) {
640       return llvm::any_of(D->clauselists(), [](const OMPClause *C) {
641         return isa<ClauseType>(C);
642       });
643     });
644   }
645
646   /// Checks for a duplicate clause amongst previously declared requires
647   /// directives
648   bool hasDuplicateRequiresClause(ArrayRef<OMPClause *> ClauseList) const {
649     bool IsDuplicate = false;
650     for (OMPClause *CNew : ClauseList) {
651       for (const OMPRequiresDecl *D : RequiresDecls) {
652         for (const OMPClause *CPrev : D->clauselists()) {
653           if (CNew->getClauseKind() == CPrev->getClauseKind()) {
654             SemaRef.Diag(CNew->getBeginLoc(),
655                          diag::err_omp_requires_clause_redeclaration)
656                 << getOpenMPClauseName(CNew->getClauseKind());
657             SemaRef.Diag(CPrev->getBeginLoc(),
658                          diag::note_omp_requires_previous_clause)
659                 << getOpenMPClauseName(CPrev->getClauseKind());
660             IsDuplicate = true;
661           }
662         }
663       }
664     }
665     return IsDuplicate;
666   }
667
668   /// Add location of previously encountered target to internal vector
669   void addTargetDirLocation(SourceLocation LocStart) {
670     TargetLocations.push_back(LocStart);
671   }
672
673   /// Add location for the first encountered atomicc directive.
674   void addAtomicDirectiveLoc(SourceLocation Loc) {
675     if (AtomicLocation.isInvalid())
676       AtomicLocation = Loc;
677   }
678
679   /// Returns the location of the first encountered atomic directive in the
680   /// module.
681   SourceLocation getAtomicDirectiveLoc() const {
682     return AtomicLocation;
683   }
684
685   // Return previously encountered target region locations.
686   ArrayRef<SourceLocation> getEncounteredTargetLocs() const {
687     return TargetLocations;
688   }
689
690   /// Set default data sharing attribute to none.
691   void setDefaultDSANone(SourceLocation Loc) {
692     getTopOfStack().DefaultAttr = DSA_none;
693     getTopOfStack().DefaultAttrLoc = Loc;
694   }
695   /// Set default data sharing attribute to shared.
696   void setDefaultDSAShared(SourceLocation Loc) {
697     getTopOfStack().DefaultAttr = DSA_shared;
698     getTopOfStack().DefaultAttrLoc = Loc;
699   }
700   /// Set default data sharing attribute to firstprivate.
701   void setDefaultDSAFirstPrivate(SourceLocation Loc) {
702     getTopOfStack().DefaultAttr = DSA_firstprivate;
703     getTopOfStack().DefaultAttrLoc = Loc;
704   }
705   /// Set default data mapping attribute to Modifier:Kind
706   void setDefaultDMAAttr(OpenMPDefaultmapClauseModifier M,
707                          OpenMPDefaultmapClauseKind Kind,
708                          SourceLocation Loc) {
709     DefaultmapInfo &DMI = getTopOfStack().DefaultmapMap[Kind];
710     DMI.ImplicitBehavior = M;
711     DMI.SLoc = Loc;
712   }
713   /// Check whether the implicit-behavior has been set in defaultmap
714   bool checkDefaultmapCategory(OpenMPDefaultmapClauseKind VariableCategory) {
715     if (VariableCategory == OMPC_DEFAULTMAP_unknown)
716       return getTopOfStack()
717                      .DefaultmapMap[OMPC_DEFAULTMAP_aggregate]
718                      .ImplicitBehavior != OMPC_DEFAULTMAP_MODIFIER_unknown ||
719              getTopOfStack()
720                      .DefaultmapMap[OMPC_DEFAULTMAP_scalar]
721                      .ImplicitBehavior != OMPC_DEFAULTMAP_MODIFIER_unknown ||
722              getTopOfStack()
723                      .DefaultmapMap[OMPC_DEFAULTMAP_pointer]
724                      .ImplicitBehavior != OMPC_DEFAULTMAP_MODIFIER_unknown;
725     return getTopOfStack().DefaultmapMap[VariableCategory].ImplicitBehavior !=
726            OMPC_DEFAULTMAP_MODIFIER_unknown;
727   }
728
729   DefaultDataSharingAttributes getDefaultDSA(unsigned Level) const {
730     return getStackSize() <= Level ? DSA_unspecified
731                                    : getStackElemAtLevel(Level).DefaultAttr;
732   }
733   DefaultDataSharingAttributes getDefaultDSA() const {
734     return isStackEmpty() ? DSA_unspecified
735                           : getTopOfStack().DefaultAttr;
736   }
737   SourceLocation getDefaultDSALocation() const {
738     return isStackEmpty() ? SourceLocation()
739                           : getTopOfStack().DefaultAttrLoc;
740   }
741   OpenMPDefaultmapClauseModifier
742   getDefaultmapModifier(OpenMPDefaultmapClauseKind Kind) const {
743     return isStackEmpty()
744                ? OMPC_DEFAULTMAP_MODIFIER_unknown
745                : getTopOfStack().DefaultmapMap[Kind].ImplicitBehavior;
746   }
747   OpenMPDefaultmapClauseModifier
748   getDefaultmapModifierAtLevel(unsigned Level,
749                                OpenMPDefaultmapClauseKind Kind) const {
750     return getStackElemAtLevel(Level).DefaultmapMap[Kind].ImplicitBehavior;
751   }
752   bool isDefaultmapCapturedByRef(unsigned Level,
753                                  OpenMPDefaultmapClauseKind Kind) const {
754     OpenMPDefaultmapClauseModifier M =
755         getDefaultmapModifierAtLevel(Level, Kind);
756     if (Kind == OMPC_DEFAULTMAP_scalar || Kind == OMPC_DEFAULTMAP_pointer) {
757       return (M == OMPC_DEFAULTMAP_MODIFIER_alloc) ||
758              (M == OMPC_DEFAULTMAP_MODIFIER_to) ||
759              (M == OMPC_DEFAULTMAP_MODIFIER_from) ||
760              (M == OMPC_DEFAULTMAP_MODIFIER_tofrom);
761     }
762     return true;
763   }
764   static bool mustBeFirstprivateBase(OpenMPDefaultmapClauseModifier M,
765                                      OpenMPDefaultmapClauseKind Kind) {
766     switch (Kind) {
767     case OMPC_DEFAULTMAP_scalar:
768     case OMPC_DEFAULTMAP_pointer:
769       return (M == OMPC_DEFAULTMAP_MODIFIER_unknown) ||
770              (M == OMPC_DEFAULTMAP_MODIFIER_firstprivate) ||
771              (M == OMPC_DEFAULTMAP_MODIFIER_default);
772     case OMPC_DEFAULTMAP_aggregate:
773       return M == OMPC_DEFAULTMAP_MODIFIER_firstprivate;
774     default:
775       break;
776     }
777     llvm_unreachable("Unexpected OpenMPDefaultmapClauseKind enum");
778   }
779   bool mustBeFirstprivateAtLevel(unsigned Level,
780                                  OpenMPDefaultmapClauseKind Kind) const {
781     OpenMPDefaultmapClauseModifier M =
782         getDefaultmapModifierAtLevel(Level, Kind);
783     return mustBeFirstprivateBase(M, Kind);
784   }
785   bool mustBeFirstprivate(OpenMPDefaultmapClauseKind Kind) const {
786     OpenMPDefaultmapClauseModifier M = getDefaultmapModifier(Kind);
787     return mustBeFirstprivateBase(M, Kind);
788   }
789
790   /// Checks if the specified variable is a threadprivate.
791   bool isThreadPrivate(VarDecl *D) {
792     const DSAVarData DVar = getTopDSA(D, false);
793     return isOpenMPThreadPrivate(DVar.CKind);
794   }
795
796   /// Marks current region as ordered (it has an 'ordered' clause).
797   void setOrderedRegion(bool IsOrdered, const Expr *Param,
798                         OMPOrderedClause *Clause) {
799     if (IsOrdered)
800       getTopOfStack().OrderedRegion.emplace(Param, Clause);
801     else
802       getTopOfStack().OrderedRegion.reset();
803   }
804   /// Returns true, if region is ordered (has associated 'ordered' clause),
805   /// false - otherwise.
806   bool isOrderedRegion() const {
807     if (const SharingMapTy *Top = getTopOfStackOrNull())
808       return Top->OrderedRegion.hasValue();
809     return false;
810   }
811   /// Returns optional parameter for the ordered region.
812   std::pair<const Expr *, OMPOrderedClause *> getOrderedRegionParam() const {
813     if (const SharingMapTy *Top = getTopOfStackOrNull())
814       if (Top->OrderedRegion.hasValue())
815         return Top->OrderedRegion.getValue();
816     return std::make_pair(nullptr, nullptr);
817   }
818   /// Returns true, if parent region is ordered (has associated
819   /// 'ordered' clause), false - otherwise.
820   bool isParentOrderedRegion() const {
821     if (const SharingMapTy *Parent = getSecondOnStackOrNull())
822       return Parent->OrderedRegion.hasValue();
823     return false;
824   }
825   /// Returns optional parameter for the ordered region.
826   std::pair<const Expr *, OMPOrderedClause *>
827   getParentOrderedRegionParam() const {
828     if (const SharingMapTy *Parent = getSecondOnStackOrNull())
829       if (Parent->OrderedRegion.hasValue())
830         return Parent->OrderedRegion.getValue();
831     return std::make_pair(nullptr, nullptr);
832   }
833   /// Marks current region as nowait (it has a 'nowait' clause).
834   void setNowaitRegion(bool IsNowait = true) {
835     getTopOfStack().NowaitRegion = IsNowait;
836   }
837   /// Returns true, if parent region is nowait (has associated
838   /// 'nowait' clause), false - otherwise.
839   bool isParentNowaitRegion() const {
840     if (const SharingMapTy *Parent = getSecondOnStackOrNull())
841       return Parent->NowaitRegion;
842     return false;
843   }
844   /// Marks parent region as cancel region.
845   void setParentCancelRegion(bool Cancel = true) {
846     if (SharingMapTy *Parent = getSecondOnStackOrNull())
847       Parent->CancelRegion |= Cancel;
848   }
849   /// Return true if current region has inner cancel construct.
850   bool isCancelRegion() const {
851     const SharingMapTy *Top = getTopOfStackOrNull();
852     return Top ? Top->CancelRegion : false;
853   }
854
855   /// Mark that parent region already has scan directive.
856   void setParentHasScanDirective(SourceLocation Loc) {
857     if (SharingMapTy *Parent = getSecondOnStackOrNull())
858       Parent->PrevScanLocation = Loc;
859   }
860   /// Return true if current region has inner cancel construct.
861   bool doesParentHasScanDirective() const {
862     const SharingMapTy *Top = getSecondOnStackOrNull();
863     return Top ? Top->PrevScanLocation.isValid() : false;
864   }
865   /// Return true if current region has inner cancel construct.
866   SourceLocation getParentScanDirectiveLoc() const {
867     const SharingMapTy *Top = getSecondOnStackOrNull();
868     return Top ? Top->PrevScanLocation : SourceLocation();
869   }
870   /// Mark that parent region already has ordered directive.
871   void setParentHasOrderedDirective(SourceLocation Loc) {
872     if (SharingMapTy *Parent = getSecondOnStackOrNull())
873       Parent->PrevOrderedLocation = Loc;
874   }
875   /// Return true if current region has inner ordered construct.
876   bool doesParentHasOrderedDirective() const {
877     const SharingMapTy *Top = getSecondOnStackOrNull();
878     return Top ? Top->PrevOrderedLocation.isValid() : false;
879   }
880   /// Returns the location of the previously specified ordered directive.
881   SourceLocation getParentOrderedDirectiveLoc() const {
882     const SharingMapTy *Top = getSecondOnStackOrNull();
883     return Top ? Top->PrevOrderedLocation : SourceLocation();
884   }
885
886   /// Set collapse value for the region.
887   void setAssociatedLoops(unsigned Val) {
888     getTopOfStack().AssociatedLoops = Val;
889     if (Val > 1)
890       getTopOfStack().HasMutipleLoops = true;
891   }
892   /// Return collapse value for region.
893   unsigned getAssociatedLoops() const {
894     const SharingMapTy *Top = getTopOfStackOrNull();
895     return Top ? Top->AssociatedLoops : 0;
896   }
897   /// Returns true if the construct is associated with multiple loops.
898   bool hasMutipleLoops() const {
899     const SharingMapTy *Top = getTopOfStackOrNull();
900     return Top ? Top->HasMutipleLoops : false;
901   }
902
903   /// Marks current target region as one with closely nested teams
904   /// region.
905   void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
906     if (SharingMapTy *Parent = getSecondOnStackOrNull())
907       Parent->InnerTeamsRegionLoc = TeamsRegionLoc;
908   }
909   /// Returns true, if current region has closely nested teams region.
910   bool hasInnerTeamsRegion() const {
911     return getInnerTeamsRegionLoc().isValid();
912   }
913   /// Returns location of the nested teams region (if any).
914   SourceLocation getInnerTeamsRegionLoc() const {
915     const SharingMapTy *Top = getTopOfStackOrNull();
916     return Top ? Top->InnerTeamsRegionLoc : SourceLocation();
917   }
918
919   Scope *getCurScope() const {
920     const SharingMapTy *Top = getTopOfStackOrNull();
921     return Top ? Top->CurScope : nullptr;
922   }
923   void setContext(DeclContext *DC) { getTopOfStack().Context = DC; }
924   SourceLocation getConstructLoc() const {
925     const SharingMapTy *Top = getTopOfStackOrNull();
926     return Top ? Top->ConstructLoc : SourceLocation();
927   }
928
929   /// Do the check specified in \a Check to all component lists and return true
930   /// if any issue is found.
931   bool checkMappableExprComponentListsForDecl(
932       const ValueDecl *VD, bool CurrentRegionOnly,
933       const llvm::function_ref<
934           bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
935                OpenMPClauseKind)>
936           Check) const {
937     if (isStackEmpty())
938       return false;
939     auto SI = begin();
940     auto SE = end();
941
942     if (SI == SE)
943       return false;
944
945     if (CurrentRegionOnly)
946       SE = std::next(SI);
947     else
948       std::advance(SI, 1);
949
950     for (; SI != SE; ++SI) {
951       auto MI = SI->MappedExprComponents.find(VD);
952       if (MI != SI->MappedExprComponents.end())
953         for (OMPClauseMappableExprCommon::MappableExprComponentListRef L :
954              MI->second.Components)
955           if (Check(L, MI->second.Kind))
956             return true;
957     }
958     return false;
959   }
960
961   /// Do the check specified in \a Check to all component lists at a given level
962   /// and return true if any issue is found.
963   bool checkMappableExprComponentListsForDeclAtLevel(
964       const ValueDecl *VD, unsigned Level,
965       const llvm::function_ref<
966           bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
967                OpenMPClauseKind)>
968           Check) const {
969     if (getStackSize() <= Level)
970       return false;
971
972     const SharingMapTy &StackElem = getStackElemAtLevel(Level);
973     auto MI = StackElem.MappedExprComponents.find(VD);
974     if (MI != StackElem.MappedExprComponents.end())
975       for (OMPClauseMappableExprCommon::MappableExprComponentListRef L :
976            MI->second.Components)
977         if (Check(L, MI->second.Kind))
978           return true;
979     return false;
980   }
981
982   /// Create a new mappable expression component list associated with a given
983   /// declaration and initialize it with the provided list of components.
984   void addMappableExpressionComponents(
985       const ValueDecl *VD,
986       OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
987       OpenMPClauseKind WhereFoundClauseKind) {
988     MappedExprComponentTy &MEC = getTopOfStack().MappedExprComponents[VD];
989     // Create new entry and append the new components there.
990     MEC.Components.resize(MEC.Components.size() + 1);
991     MEC.Components.back().append(Components.begin(), Components.end());
992     MEC.Kind = WhereFoundClauseKind;
993   }
994
995   unsigned getNestingLevel() const {
996     assert(!isStackEmpty());
997     return getStackSize() - 1;
998   }
999   void addDoacrossDependClause(OMPDependClause *C,
1000                                const OperatorOffsetTy &OpsOffs) {
1001     SharingMapTy *Parent = getSecondOnStackOrNull();
1002     assert(Parent && isOpenMPWorksharingDirective(Parent->Directive));
1003     Parent->DoacrossDepends.try_emplace(C, OpsOffs);
1004   }
1005   llvm::iterator_range<DoacrossDependMapTy::const_iterator>
1006   getDoacrossDependClauses() const {
1007     const SharingMapTy &StackElem = getTopOfStack();
1008     if (isOpenMPWorksharingDirective(StackElem.Directive)) {
1009       const DoacrossDependMapTy &Ref = StackElem.DoacrossDepends;
1010       return llvm::make_range(Ref.begin(), Ref.end());
1011     }
1012     return llvm::make_range(StackElem.DoacrossDepends.end(),
1013                             StackElem.DoacrossDepends.end());
1014   }
1015
1016   // Store types of classes which have been explicitly mapped
1017   void addMappedClassesQualTypes(QualType QT) {
1018     SharingMapTy &StackElem = getTopOfStack();
1019     StackElem.MappedClassesQualTypes.insert(QT);
1020   }
1021
1022   // Return set of mapped classes types
1023   bool isClassPreviouslyMapped(QualType QT) const {
1024     const SharingMapTy &StackElem = getTopOfStack();
1025     return StackElem.MappedClassesQualTypes.count(QT) != 0;
1026   }
1027
1028   /// Adds global declare target to the parent target region.
1029   void addToParentTargetRegionLinkGlobals(DeclRefExpr *E) {
1030     assert(*OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
1031                E->getDecl()) == OMPDeclareTargetDeclAttr::MT_Link &&
1032            "Expected declare target link global.");
1033     for (auto &Elem : *this) {
1034       if (isOpenMPTargetExecutionDirective(Elem.Directive)) {
1035         Elem.DeclareTargetLinkVarDecls.push_back(E);
1036         return;
1037       }
1038     }
1039   }
1040
1041   /// Returns the list of globals with declare target link if current directive
1042   /// is target.
1043   ArrayRef<DeclRefExpr *> getLinkGlobals() const {
1044     assert(isOpenMPTargetExecutionDirective(getCurrentDirective()) &&
1045            "Expected target executable directive.");
1046     return getTopOfStack().DeclareTargetLinkVarDecls;
1047   }
1048
1049   /// Adds list of allocators expressions.
1050   void addInnerAllocatorExpr(Expr *E) {
1051     getTopOfStack().InnerUsedAllocators.push_back(E);
1052   }
1053   /// Return list of used allocators.
1054   ArrayRef<Expr *> getInnerAllocators() const {
1055     return getTopOfStack().InnerUsedAllocators;
1056   }
1057   /// Marks the declaration as implicitly firstprivate nin the task-based
1058   /// regions.
1059   void addImplicitTaskFirstprivate(unsigned Level, Decl *D) {
1060     getStackElemAtLevel(Level).ImplicitTaskFirstprivates.insert(D);
1061   }
1062   /// Checks if the decl is implicitly firstprivate in the task-based region.
1063   bool isImplicitTaskFirstprivate(Decl *D) const {
1064     return getTopOfStack().ImplicitTaskFirstprivates.count(D) > 0;
1065   }
1066
1067   /// Marks decl as used in uses_allocators clause as the allocator.
1068   void addUsesAllocatorsDecl(const Decl *D, UsesAllocatorsDeclKind Kind) {
1069     getTopOfStack().UsesAllocatorsDecls.try_emplace(D, Kind);
1070   }
1071   /// Checks if specified decl is used in uses allocator clause as the
1072   /// allocator.
1073   Optional<UsesAllocatorsDeclKind> isUsesAllocatorsDecl(unsigned Level,
1074                                                         const Decl *D) const {
1075     const SharingMapTy &StackElem = getTopOfStack();
1076     auto I = StackElem.UsesAllocatorsDecls.find(D);
1077     if (I == StackElem.UsesAllocatorsDecls.end())
1078       return None;
1079     return I->getSecond();
1080   }
1081   Optional<UsesAllocatorsDeclKind> isUsesAllocatorsDecl(const Decl *D) const {
1082     const SharingMapTy &StackElem = getTopOfStack();
1083     auto I = StackElem.UsesAllocatorsDecls.find(D);
1084     if (I == StackElem.UsesAllocatorsDecls.end())
1085       return None;
1086     return I->getSecond();
1087   }
1088
1089   void addDeclareMapperVarRef(Expr *Ref) {
1090     SharingMapTy &StackElem = getTopOfStack();
1091     StackElem.DeclareMapperVar = Ref;
1092   }
1093   const Expr *getDeclareMapperVarRef() const {
1094     const SharingMapTy *Top = getTopOfStackOrNull();
1095     return Top ? Top->DeclareMapperVar : nullptr;
1096   }
1097 };
1098
1099 bool isImplicitTaskingRegion(OpenMPDirectiveKind DKind) {
1100   return isOpenMPParallelDirective(DKind) || isOpenMPTeamsDirective(DKind);
1101 }
1102
1103 bool isImplicitOrExplicitTaskingRegion(OpenMPDirectiveKind DKind) {
1104   return isImplicitTaskingRegion(DKind) || isOpenMPTaskingDirective(DKind) ||
1105          DKind == OMPD_unknown;
1106 }
1107
1108 } // namespace
1109
1110 static const Expr *getExprAsWritten(const Expr *E) {
1111   if (const auto *FE = dyn_cast<FullExpr>(E))
1112     E = FE->getSubExpr();
1113
1114   if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
1115     E = MTE->getSubExpr();
1116
1117   while (const auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
1118     E = Binder->getSubExpr();
1119
1120   if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
1121     E = ICE->getSubExprAsWritten();
1122   return E->IgnoreParens();
1123 }
1124
1125 static Expr *getExprAsWritten(Expr *E) {
1126   return const_cast<Expr *>(getExprAsWritten(const_cast<const Expr *>(E)));
1127 }
1128
1129 static const ValueDecl *getCanonicalDecl(const ValueDecl *D) {
1130   if (const auto *CED = dyn_cast<OMPCapturedExprDecl>(D))
1131     if (const auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
1132       D = ME->getMemberDecl();
1133   const auto *VD = dyn_cast<VarDecl>(D);
1134   const auto *FD = dyn_cast<FieldDecl>(D);
1135   if (VD != nullptr) {
1136     VD = VD->getCanonicalDecl();
1137     D = VD;
1138   } else {
1139     assert(FD);
1140     FD = FD->getCanonicalDecl();
1141     D = FD;
1142   }
1143   return D;
1144 }
1145
1146 static ValueDecl *getCanonicalDecl(ValueDecl *D) {
1147   return const_cast<ValueDecl *>(
1148       getCanonicalDecl(const_cast<const ValueDecl *>(D)));
1149 }
1150
1151 DSAStackTy::DSAVarData DSAStackTy::getDSA(const_iterator &Iter,
1152                                           ValueDecl *D) const {
1153   D = getCanonicalDecl(D);
1154   auto *VD = dyn_cast<VarDecl>(D);
1155   const auto *FD = dyn_cast<FieldDecl>(D);
1156   DSAVarData DVar;
1157   if (Iter == end()) {
1158     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1159     // in a region but not in construct]
1160     //  File-scope or namespace-scope variables referenced in called routines
1161     //  in the region are shared unless they appear in a threadprivate
1162     //  directive.
1163     if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(VD))
1164       DVar.CKind = OMPC_shared;
1165
1166     // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
1167     // in a region but not in construct]
1168     //  Variables with static storage duration that are declared in called
1169     //  routines in the region are shared.
1170     if (VD && VD->hasGlobalStorage())
1171       DVar.CKind = OMPC_shared;
1172
1173     // Non-static data members are shared by default.
1174     if (FD)
1175       DVar.CKind = OMPC_shared;
1176
1177     return DVar;
1178   }
1179
1180   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1181   // in a Construct, C/C++, predetermined, p.1]
1182   // Variables with automatic storage duration that are declared in a scope
1183   // inside the construct are private.
1184   if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
1185       (VD->getStorageClass() == StorageClass::Auto ||
1186        VD->getStorageClass() == StorageClass::None)) {
1187     DVar.CKind = OMPC_private;
1188     return DVar;
1189   }
1190
1191   DVar.DKind = Iter->Directive;
1192   // Explicitly specified attributes and local variables with predetermined
1193   // attributes.
1194   if (Iter->SharingMap.count(D)) {
1195     const DSAInfo &Data = Iter->SharingMap.lookup(D);
1196     DVar.RefExpr = Data.RefExpr.getPointer();
1197     DVar.PrivateCopy = Data.PrivateCopy;
1198     DVar.CKind = Data.Attributes;
1199     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
1200     DVar.Modifier = Data.Modifier;
1201     DVar.AppliedToPointee = Data.AppliedToPointee;
1202     return DVar;
1203   }
1204
1205   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1206   // in a Construct, C/C++, implicitly determined, p.1]
1207   //  In a parallel or task construct, the data-sharing attributes of these
1208   //  variables are determined by the default clause, if present.
1209   switch (Iter->DefaultAttr) {
1210   case DSA_shared:
1211     DVar.CKind = OMPC_shared;
1212     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
1213     return DVar;
1214   case DSA_none:
1215     return DVar;
1216   case DSA_firstprivate:
1217     if (VD->getStorageDuration() == SD_Static &&
1218         VD->getDeclContext()->isFileContext()) {
1219       DVar.CKind = OMPC_unknown;
1220     } else {
1221       DVar.CKind = OMPC_firstprivate;
1222     }
1223     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
1224     return DVar;
1225   case DSA_unspecified:
1226     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1227     // in a Construct, implicitly determined, p.2]
1228     //  In a parallel construct, if no default clause is present, these
1229     //  variables are shared.
1230     DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
1231     if ((isOpenMPParallelDirective(DVar.DKind) &&
1232          !isOpenMPTaskLoopDirective(DVar.DKind)) ||
1233         isOpenMPTeamsDirective(DVar.DKind)) {
1234       DVar.CKind = OMPC_shared;
1235       return DVar;
1236     }
1237
1238     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1239     // in a Construct, implicitly determined, p.4]
1240     //  In a task construct, if no default clause is present, a variable that in
1241     //  the enclosing context is determined to be shared by all implicit tasks
1242     //  bound to the current team is shared.
1243     if (isOpenMPTaskingDirective(DVar.DKind)) {
1244       DSAVarData DVarTemp;
1245       const_iterator I = Iter, E = end();
1246       do {
1247         ++I;
1248         // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
1249         // Referenced in a Construct, implicitly determined, p.6]
1250         //  In a task construct, if no default clause is present, a variable
1251         //  whose data-sharing attribute is not determined by the rules above is
1252         //  firstprivate.
1253         DVarTemp = getDSA(I, D);
1254         if (DVarTemp.CKind != OMPC_shared) {
1255           DVar.RefExpr = nullptr;
1256           DVar.CKind = OMPC_firstprivate;
1257           return DVar;
1258         }
1259       } while (I != E && !isImplicitTaskingRegion(I->Directive));
1260       DVar.CKind =
1261           (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
1262       return DVar;
1263     }
1264   }
1265   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1266   // in a Construct, implicitly determined, p.3]
1267   //  For constructs other than task, if no default clause is present, these
1268   //  variables inherit their data-sharing attributes from the enclosing
1269   //  context.
1270   return getDSA(++Iter, D);
1271 }
1272
1273 const Expr *DSAStackTy::addUniqueAligned(const ValueDecl *D,
1274                                          const Expr *NewDE) {
1275   assert(!isStackEmpty() && "Data sharing attributes stack is empty");
1276   D = getCanonicalDecl(D);
1277   SharingMapTy &StackElem = getTopOfStack();
1278   auto It = StackElem.AlignedMap.find(D);
1279   if (It == StackElem.AlignedMap.end()) {
1280     assert(NewDE && "Unexpected nullptr expr to be added into aligned map");
1281     StackElem.AlignedMap[D] = NewDE;
1282     return nullptr;
1283   }
1284   assert(It->second && "Unexpected nullptr expr in the aligned map");
1285   return It->second;
1286 }
1287
1288 const Expr *DSAStackTy::addUniqueNontemporal(const ValueDecl *D,
1289                                              const Expr *NewDE) {
1290   assert(!isStackEmpty() && "Data sharing attributes stack is empty");
1291   D = getCanonicalDecl(D);
1292   SharingMapTy &StackElem = getTopOfStack();
1293   auto It = StackElem.NontemporalMap.find(D);
1294   if (It == StackElem.NontemporalMap.end()) {
1295     assert(NewDE && "Unexpected nullptr expr to be added into aligned map");
1296     StackElem.NontemporalMap[D] = NewDE;
1297     return nullptr;
1298   }
1299   assert(It->second && "Unexpected nullptr expr in the aligned map");
1300   return It->second;
1301 }
1302
1303 void DSAStackTy::addLoopControlVariable(const ValueDecl *D, VarDecl *Capture) {
1304   assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
1305   D = getCanonicalDecl(D);
1306   SharingMapTy &StackElem = getTopOfStack();
1307   StackElem.LCVMap.try_emplace(
1308       D, LCDeclInfo(StackElem.LCVMap.size() + 1, Capture));
1309 }
1310
1311 const DSAStackTy::LCDeclInfo
1312 DSAStackTy::isLoopControlVariable(const ValueDecl *D) const {
1313   assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
1314   D = getCanonicalDecl(D);
1315   const SharingMapTy &StackElem = getTopOfStack();
1316   auto It = StackElem.LCVMap.find(D);
1317   if (It != StackElem.LCVMap.end())
1318     return It->second;
1319   return {0, nullptr};
1320 }
1321
1322 const DSAStackTy::LCDeclInfo
1323 DSAStackTy::isLoopControlVariable(const ValueDecl *D, unsigned Level) const {
1324   assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
1325   D = getCanonicalDecl(D);
1326   for (unsigned I = Level + 1; I > 0; --I) {
1327     const SharingMapTy &StackElem = getStackElemAtLevel(I - 1);
1328     auto It = StackElem.LCVMap.find(D);
1329     if (It != StackElem.LCVMap.end())
1330       return It->second;
1331   }
1332   return {0, nullptr};
1333 }
1334
1335 const DSAStackTy::LCDeclInfo
1336 DSAStackTy::isParentLoopControlVariable(const ValueDecl *D) const {
1337   const SharingMapTy *Parent = getSecondOnStackOrNull();
1338   assert(Parent && "Data-sharing attributes stack is empty");
1339   D = getCanonicalDecl(D);
1340   auto It = Parent->LCVMap.find(D);
1341   if (It != Parent->LCVMap.end())
1342     return It->second;
1343   return {0, nullptr};
1344 }
1345
1346 const ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) const {
1347   const SharingMapTy *Parent = getSecondOnStackOrNull();
1348   assert(Parent && "Data-sharing attributes stack is empty");
1349   if (Parent->LCVMap.size() < I)
1350     return nullptr;
1351   for (const auto &Pair : Parent->LCVMap)
1352     if (Pair.second.first == I)
1353       return Pair.first;
1354   return nullptr;
1355 }
1356
1357 void DSAStackTy::addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A,
1358                         DeclRefExpr *PrivateCopy, unsigned Modifier,
1359                         bool AppliedToPointee) {
1360   D = getCanonicalDecl(D);
1361   if (A == OMPC_threadprivate) {
1362     DSAInfo &Data = Threadprivates[D];
1363     Data.Attributes = A;
1364     Data.RefExpr.setPointer(E);
1365     Data.PrivateCopy = nullptr;
1366     Data.Modifier = Modifier;
1367   } else {
1368     DSAInfo &Data = getTopOfStack().SharingMap[D];
1369     assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
1370            (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||
1371            (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||
1372            (isLoopControlVariable(D).first && A == OMPC_private));
1373     Data.Modifier = Modifier;
1374     if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
1375       Data.RefExpr.setInt(/*IntVal=*/true);
1376       return;
1377     }
1378     const bool IsLastprivate =
1379         A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
1380     Data.Attributes = A;
1381     Data.RefExpr.setPointerAndInt(E, IsLastprivate);
1382     Data.PrivateCopy = PrivateCopy;
1383     Data.AppliedToPointee = AppliedToPointee;
1384     if (PrivateCopy) {
1385       DSAInfo &Data = getTopOfStack().SharingMap[PrivateCopy->getDecl()];
1386       Data.Modifier = Modifier;
1387       Data.Attributes = A;
1388       Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
1389       Data.PrivateCopy = nullptr;
1390       Data.AppliedToPointee = AppliedToPointee;
1391     }
1392   }
1393 }
1394
1395 /// Build a variable declaration for OpenMP loop iteration variable.
1396 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
1397                              StringRef Name, const AttrVec *Attrs = nullptr,
1398                              DeclRefExpr *OrigRef = nullptr) {
1399   DeclContext *DC = SemaRef.CurContext;
1400   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1401   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1402   auto *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo,
1403                                StorageClass::None);
1404   if (Attrs) {
1405     for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
1406          I != E; ++I)
1407       Decl->addAttr(*I);
1408   }
1409   Decl->setImplicit();
1410   if (OrigRef) {
1411     Decl->addAttr(
1412         OMPReferencedVarAttr::CreateImplicit(SemaRef.Context, OrigRef));
1413   }
1414   return Decl;
1415 }
1416
1417 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
1418                                      SourceLocation Loc,
1419                                      bool RefersToCapture = false) {
1420   D->setReferenced();
1421   D->markUsed(S.Context);
1422   return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
1423                              SourceLocation(), D, RefersToCapture, Loc, Ty,
1424                              VK_LValue);
1425 }
1426
1427 void DSAStackTy::addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
1428                                            BinaryOperatorKind BOK) {
1429   D = getCanonicalDecl(D);
1430   assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
1431   assert(
1432       getTopOfStack().SharingMap[D].Attributes == OMPC_reduction &&
1433       "Additional reduction info may be specified only for reduction items.");
1434   ReductionData &ReductionData = getTopOfStack().ReductionMap[D];
1435   assert(ReductionData.ReductionRange.isInvalid() &&
1436          (getTopOfStack().Directive == OMPD_taskgroup ||
1437           ((isOpenMPParallelDirective(getTopOfStack().Directive) ||
1438             isOpenMPWorksharingDirective(getTopOfStack().Directive)) &&
1439            !isOpenMPSimdDirective(getTopOfStack().Directive))) &&
1440          "Additional reduction info may be specified only once for reduction "
1441          "items.");
1442   ReductionData.set(BOK, SR);
1443   Expr *&TaskgroupReductionRef =
1444       getTopOfStack().TaskgroupReductionRef;
1445   if (!TaskgroupReductionRef) {
1446     VarDecl *VD = buildVarDecl(SemaRef, SR.getBegin(),
1447                                SemaRef.Context.VoidPtrTy, ".task_red.");
1448     TaskgroupReductionRef =
1449         buildDeclRefExpr(SemaRef, VD, SemaRef.Context.VoidPtrTy, SR.getBegin());
1450   }
1451 }
1452
1453 void DSAStackTy::addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
1454                                            const Expr *ReductionRef) {
1455   D = getCanonicalDecl(D);
1456   assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
1457   assert(
1458       getTopOfStack().SharingMap[D].Attributes == OMPC_reduction &&
1459       "Additional reduction info may be specified only for reduction items.");
1460   ReductionData &ReductionData = getTopOfStack().ReductionMap[D];
1461   assert(ReductionData.ReductionRange.isInvalid() &&
1462          (getTopOfStack().Directive == OMPD_taskgroup ||
1463           ((isOpenMPParallelDirective(getTopOfStack().Directive) ||
1464             isOpenMPWorksharingDirective(getTopOfStack().Directive)) &&
1465            !isOpenMPSimdDirective(getTopOfStack().Directive))) &&
1466          "Additional reduction info may be specified only once for reduction "
1467          "items.");
1468   ReductionData.set(ReductionRef, SR);
1469   Expr *&TaskgroupReductionRef =
1470       getTopOfStack().TaskgroupReductionRef;
1471   if (!TaskgroupReductionRef) {
1472     VarDecl *VD = buildVarDecl(SemaRef, SR.getBegin(),
1473                                SemaRef.Context.VoidPtrTy, ".task_red.");
1474     TaskgroupReductionRef =
1475         buildDeclRefExpr(SemaRef, VD, SemaRef.Context.VoidPtrTy, SR.getBegin());
1476   }
1477 }
1478
1479 const DSAStackTy::DSAVarData DSAStackTy::getTopMostTaskgroupReductionData(
1480     const ValueDecl *D, SourceRange &SR, BinaryOperatorKind &BOK,
1481     Expr *&TaskgroupDescriptor) const {
1482   D = getCanonicalDecl(D);
1483   assert(!isStackEmpty() && "Data-sharing attributes stack is empty.");
1484   for (const_iterator I = begin() + 1, E = end(); I != E; ++I) {
1485     const DSAInfo &Data = I->SharingMap.lookup(D);
1486     if (Data.Attributes != OMPC_reduction ||
1487         Data.Modifier != OMPC_REDUCTION_task)
1488       continue;
1489     const ReductionData &ReductionData = I->ReductionMap.lookup(D);
1490     if (!ReductionData.ReductionOp ||
1491         ReductionData.ReductionOp.is<const Expr *>())
1492       return DSAVarData();
1493     SR = ReductionData.ReductionRange;
1494     BOK = ReductionData.ReductionOp.get<ReductionData::BOKPtrType>();
1495     assert(I->TaskgroupReductionRef && "taskgroup reduction reference "
1496                                        "expression for the descriptor is not "
1497                                        "set.");
1498     TaskgroupDescriptor = I->TaskgroupReductionRef;
1499     return DSAVarData(I->Directive, OMPC_reduction, Data.RefExpr.getPointer(),
1500                       Data.PrivateCopy, I->DefaultAttrLoc, OMPC_REDUCTION_task,
1501                       /*AppliedToPointee=*/false);
1502   }
1503   return DSAVarData();
1504 }
1505
1506 const DSAStackTy::DSAVarData DSAStackTy::getTopMostTaskgroupReductionData(
1507     const ValueDecl *D, SourceRange &SR, const Expr *&ReductionRef,
1508     Expr *&TaskgroupDescriptor) const {
1509   D = getCanonicalDecl(D);
1510   assert(!isStackEmpty() && "Data-sharing attributes stack is empty.");
1511   for (const_iterator I = begin() + 1, E = end(); I != E; ++I) {
1512     const DSAInfo &Data = I->SharingMap.lookup(D);
1513     if (Data.Attributes != OMPC_reduction ||
1514         Data.Modifier != OMPC_REDUCTION_task)
1515       continue;
1516     const ReductionData &ReductionData = I->ReductionMap.lookup(D);
1517     if (!ReductionData.ReductionOp ||
1518         !ReductionData.ReductionOp.is<const Expr *>())
1519       return DSAVarData();
1520     SR = ReductionData.ReductionRange;
1521     ReductionRef = ReductionData.ReductionOp.get<const Expr *>();
1522     assert(I->TaskgroupReductionRef && "taskgroup reduction reference "
1523                                        "expression for the descriptor is not "
1524                                        "set.");
1525     TaskgroupDescriptor = I->TaskgroupReductionRef;
1526     return DSAVarData(I->Directive, OMPC_reduction, Data.RefExpr.getPointer(),
1527                       Data.PrivateCopy, I->DefaultAttrLoc, OMPC_REDUCTION_task,
1528                       /*AppliedToPointee=*/false);
1529   }
1530   return DSAVarData();
1531 }
1532
1533 bool DSAStackTy::isOpenMPLocal(VarDecl *D, const_iterator I) const {
1534   D = D->getCanonicalDecl();
1535   for (const_iterator E = end(); I != E; ++I) {
1536     if (isImplicitOrExplicitTaskingRegion(I->Directive) ||
1537         isOpenMPTargetExecutionDirective(I->Directive)) {
1538       if (I->CurScope) {
1539         Scope *TopScope = I->CurScope->getParent();
1540         Scope *CurScope = getCurScope();
1541         while (CurScope && CurScope != TopScope && !CurScope->isDeclScope(D))
1542           CurScope = CurScope->getParent();
1543         return CurScope != TopScope;
1544       }
1545       for (DeclContext *DC = D->getDeclContext(); DC; DC = DC->getParent())
1546         if (I->Context == DC)
1547           return true;
1548       return false;
1549     }
1550   }
1551   return false;
1552 }
1553
1554 static bool isConstNotMutableType(Sema &SemaRef, QualType Type,
1555                                   bool AcceptIfMutable = true,
1556                                   bool *IsClassType = nullptr) {
1557   ASTContext &Context = SemaRef.getASTContext();
1558   Type = Type.getNonReferenceType().getCanonicalType();
1559   bool IsConstant = Type.isConstant(Context);
1560   Type = Context.getBaseElementType(Type);
1561   const CXXRecordDecl *RD = AcceptIfMutable && SemaRef.getLangOpts().CPlusPlus
1562                                 ? Type->getAsCXXRecordDecl()
1563                                 : nullptr;
1564   if (const auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
1565     if (const ClassTemplateDecl *CTD = CTSD->getSpecializedTemplate())
1566       RD = CTD->getTemplatedDecl();
1567   if (IsClassType)
1568     *IsClassType = RD;
1569   return IsConstant && !(SemaRef.getLangOpts().CPlusPlus && RD &&
1570                          RD->hasDefinition() && RD->hasMutableFields());
1571 }
1572
1573 static bool rejectConstNotMutableType(Sema &SemaRef, const ValueDecl *D,
1574                                       QualType Type, OpenMPClauseKind CKind,
1575                                       SourceLocation ELoc,
1576                                       bool AcceptIfMutable = true,
1577                                       bool ListItemNotVar = false) {
1578   ASTContext &Context = SemaRef.getASTContext();
1579   bool IsClassType;
1580   if (isConstNotMutableType(SemaRef, Type, AcceptIfMutable, &IsClassType)) {
1581     unsigned Diag = ListItemNotVar
1582                         ? diag::err_omp_const_list_item
1583                         : IsClassType ? diag::err_omp_const_not_mutable_variable
1584                                       : diag::err_omp_const_variable;
1585     SemaRef.Diag(ELoc, Diag) << getOpenMPClauseName(CKind);
1586     if (!ListItemNotVar && D) {
1587       const VarDecl *VD = dyn_cast<VarDecl>(D);
1588       bool IsDecl = !VD || VD->isThisDeclarationADefinition(Context) ==
1589                                VarDecl::DeclarationOnly;
1590       SemaRef.Diag(D->getLocation(),
1591                    IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1592           << D;
1593     }
1594     return true;
1595   }
1596   return false;
1597 }
1598
1599 const DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D,
1600                                                    bool FromParent) {
1601   D = getCanonicalDecl(D);
1602   DSAVarData DVar;
1603
1604   auto *VD = dyn_cast<VarDecl>(D);
1605   auto TI = Threadprivates.find(D);
1606   if (TI != Threadprivates.end()) {
1607     DVar.RefExpr = TI->getSecond().RefExpr.getPointer();
1608     DVar.CKind = OMPC_threadprivate;
1609     DVar.Modifier = TI->getSecond().Modifier;
1610     return DVar;
1611   }
1612   if (VD && VD->hasAttr<OMPThreadPrivateDeclAttr>()) {
1613     DVar.RefExpr = buildDeclRefExpr(
1614         SemaRef, VD, D->getType().getNonReferenceType(),
1615         VD->getAttr<OMPThreadPrivateDeclAttr>()->getLocation());
1616     DVar.CKind = OMPC_threadprivate;
1617     addDSA(D, DVar.RefExpr, OMPC_threadprivate);
1618     return DVar;
1619   }
1620   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1621   // in a Construct, C/C++, predetermined, p.1]
1622   //  Variables appearing in threadprivate directives are threadprivate.
1623   if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
1624        !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
1625          SemaRef.getLangOpts().OpenMPUseTLS &&
1626          SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
1627       (VD && VD->getStorageClass() == StorageClass::Register &&
1628        VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
1629     DVar.RefExpr = buildDeclRefExpr(
1630         SemaRef, VD, D->getType().getNonReferenceType(), D->getLocation());
1631     DVar.CKind = OMPC_threadprivate;
1632     addDSA(D, DVar.RefExpr, OMPC_threadprivate);
1633     return DVar;
1634   }
1635   if (SemaRef.getLangOpts().OpenMPCUDAMode && VD &&
1636       VD->isLocalVarDeclOrParm() && !isStackEmpty() &&
1637       !isLoopControlVariable(D).first) {
1638     const_iterator IterTarget =
1639         std::find_if(begin(), end(), [](const SharingMapTy &Data) {
1640           return isOpenMPTargetExecutionDirective(Data.Directive);
1641         });
1642     if (IterTarget != end()) {
1643       const_iterator ParentIterTarget = IterTarget + 1;
1644       for (const_iterator Iter = begin();
1645            Iter != ParentIterTarget; ++Iter) {
1646         if (isOpenMPLocal(VD, Iter)) {
1647           DVar.RefExpr =
1648               buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
1649                                D->getLocation());
1650           DVar.CKind = OMPC_threadprivate;
1651           return DVar;
1652         }
1653       }
1654       if (!isClauseParsingMode() || IterTarget != begin()) {
1655         auto DSAIter = IterTarget->SharingMap.find(D);
1656         if (DSAIter != IterTarget->SharingMap.end() &&
1657             isOpenMPPrivate(DSAIter->getSecond().Attributes)) {
1658           DVar.RefExpr = DSAIter->getSecond().RefExpr.getPointer();
1659           DVar.CKind = OMPC_threadprivate;
1660           return DVar;
1661         }
1662         const_iterator End = end();
1663         if (!SemaRef.isOpenMPCapturedByRef(
1664                 D, std::distance(ParentIterTarget, End),
1665                 /*OpenMPCaptureLevel=*/0)) {
1666           DVar.RefExpr =
1667               buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
1668                                IterTarget->ConstructLoc);
1669           DVar.CKind = OMPC_threadprivate;
1670           return DVar;
1671         }
1672       }
1673     }
1674   }
1675
1676   if (isStackEmpty())
1677     // Not in OpenMP execution region and top scope was already checked.
1678     return DVar;
1679
1680   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1681   // in a Construct, C/C++, predetermined, p.4]
1682   //  Static data members are shared.
1683   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1684   // in a Construct, C/C++, predetermined, p.7]
1685   //  Variables with static storage duration that are declared in a scope
1686   //  inside the construct are shared.
1687   if (VD && VD->isStaticDataMember()) {
1688     // Check for explicitly specified attributes.
1689     const_iterator I = begin();
1690     const_iterator EndI = end();
1691     if (FromParent && I != EndI)
1692       ++I;
1693     if (I != EndI) {
1694       auto It = I->SharingMap.find(D);
1695       if (It != I->SharingMap.end()) {
1696         const DSAInfo &Data = It->getSecond();
1697         DVar.RefExpr = Data.RefExpr.getPointer();
1698         DVar.PrivateCopy = Data.PrivateCopy;
1699         DVar.CKind = Data.Attributes;
1700         DVar.ImplicitDSALoc = I->DefaultAttrLoc;
1701         DVar.DKind = I->Directive;
1702         DVar.Modifier = Data.Modifier;
1703         DVar.AppliedToPointee = Data.AppliedToPointee;
1704         return DVar;
1705       }
1706     }
1707
1708     DVar.CKind = OMPC_shared;
1709     return DVar;
1710   }
1711
1712   auto &&MatchesAlways = [](OpenMPDirectiveKind) { return true; };
1713   // The predetermined shared attribute for const-qualified types having no
1714   // mutable members was removed after OpenMP 3.1.
1715   if (SemaRef.LangOpts.OpenMP <= 31) {
1716     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
1717     // in a Construct, C/C++, predetermined, p.6]
1718     //  Variables with const qualified type having no mutable member are
1719     //  shared.
1720     if (isConstNotMutableType(SemaRef, D->getType())) {
1721       // Variables with const-qualified type having no mutable member may be
1722       // listed in a firstprivate clause, even if they are static data members.
1723       DSAVarData DVarTemp = hasInnermostDSA(
1724           D,
1725           [](OpenMPClauseKind C, bool) {
1726             return C == OMPC_firstprivate || C == OMPC_shared;
1727           },
1728           MatchesAlways, FromParent);
1729       if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
1730         return DVarTemp;
1731
1732       DVar.CKind = OMPC_shared;
1733       return DVar;
1734     }
1735   }
1736
1737   // Explicitly specified attributes and local variables with predetermined
1738   // attributes.
1739   const_iterator I = begin();
1740   const_iterator EndI = end();
1741   if (FromParent && I != EndI)
1742     ++I;
1743   if (I == EndI)
1744     return DVar;
1745   auto It = I->SharingMap.find(D);
1746   if (It != I->SharingMap.end()) {
1747     const DSAInfo &Data = It->getSecond();
1748     DVar.RefExpr = Data.RefExpr.getPointer();
1749     DVar.PrivateCopy = Data.PrivateCopy;
1750     DVar.CKind = Data.Attributes;
1751     DVar.ImplicitDSALoc = I->DefaultAttrLoc;
1752     DVar.DKind = I->Directive;
1753     DVar.Modifier = Data.Modifier;
1754     DVar.AppliedToPointee = Data.AppliedToPointee;
1755   }
1756
1757   return DVar;
1758 }
1759
1760 const DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
1761                                                         bool FromParent) const {
1762   if (isStackEmpty()) {
1763     const_iterator I;
1764     return getDSA(I, D);
1765   }
1766   D = getCanonicalDecl(D);
1767   const_iterator StartI = begin();
1768   const_iterator EndI = end();
1769   if (FromParent && StartI != EndI)
1770     ++StartI;
1771   return getDSA(StartI, D);
1772 }
1773
1774 const DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
1775                                                         unsigned Level) const {
1776   if (getStackSize() <= Level)
1777     return DSAVarData();
1778   D = getCanonicalDecl(D);
1779   const_iterator StartI = std::next(begin(), getStackSize() - 1 - Level);
1780   return getDSA(StartI, D);
1781 }
1782
1783 const DSAStackTy::DSAVarData
1784 DSAStackTy::hasDSA(ValueDecl *D,
1785                    const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
1786                    const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
1787                    bool FromParent) const {
1788   if (isStackEmpty())
1789     return {};
1790   D = getCanonicalDecl(D);
1791   const_iterator I = begin();
1792   const_iterator EndI = end();
1793   if (FromParent && I != EndI)
1794     ++I;
1795   for (; I != EndI; ++I) {
1796     if (!DPred(I->Directive) &&
1797         !isImplicitOrExplicitTaskingRegion(I->Directive))
1798       continue;
1799     const_iterator NewI = I;
1800     DSAVarData DVar = getDSA(NewI, D);
1801     if (I == NewI && CPred(DVar.CKind, DVar.AppliedToPointee))
1802       return DVar;
1803   }
1804   return {};
1805 }
1806
1807 const DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
1808     ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
1809     const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
1810     bool FromParent) const {
1811   if (isStackEmpty())
1812     return {};
1813   D = getCanonicalDecl(D);
1814   const_iterator StartI = begin();
1815   const_iterator EndI = end();
1816   if (FromParent && StartI != EndI)
1817     ++StartI;
1818   if (StartI == EndI || !DPred(StartI->Directive))
1819     return {};
1820   const_iterator NewI = StartI;
1821   DSAVarData DVar = getDSA(NewI, D);
1822   return (NewI == StartI && CPred(DVar.CKind, DVar.AppliedToPointee))
1823              ? DVar
1824              : DSAVarData();
1825 }
1826
1827 bool DSAStackTy::hasExplicitDSA(
1828     const ValueDecl *D,
1829     const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
1830     unsigned Level, bool NotLastprivate) const {
1831   if (getStackSize() <= Level)
1832     return false;
1833   D = getCanonicalDecl(D);
1834   const SharingMapTy &StackElem = getStackElemAtLevel(Level);
1835   auto I = StackElem.SharingMap.find(D);
1836   if (I != StackElem.SharingMap.end() && I->getSecond().RefExpr.getPointer() &&
1837       CPred(I->getSecond().Attributes, I->getSecond().AppliedToPointee) &&
1838       (!NotLastprivate || !I->getSecond().RefExpr.getInt()))
1839     return true;
1840   // Check predetermined rules for the loop control variables.
1841   auto LI = StackElem.LCVMap.find(D);
1842   if (LI != StackElem.LCVMap.end())
1843     return CPred(OMPC_private, /*AppliedToPointee=*/false);
1844   return false;
1845 }
1846
1847 bool DSAStackTy::hasExplicitDirective(
1848     const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
1849     unsigned Level) const {
1850   if (getStackSize() <= Level)
1851     return false;
1852   const SharingMapTy &StackElem = getStackElemAtLevel(Level);
1853   return DPred(StackElem.Directive);
1854 }
1855
1856 bool DSAStackTy::hasDirective(
1857     const llvm::function_ref<bool(OpenMPDirectiveKind,
1858                                   const DeclarationNameInfo &, SourceLocation)>
1859         DPred,
1860     bool FromParent) const {
1861   // We look only in the enclosing region.
1862   size_t Skip = FromParent ? 2 : 1;
1863   for (const_iterator I = begin() + std::min(Skip, getStackSize()), E = end();
1864        I != E; ++I) {
1865     if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc))
1866       return true;
1867   }
1868   return false;
1869 }
1870
1871 void Sema::InitDataSharingAttributesStack() {
1872   VarDataSharingAttributesStack = new DSAStackTy(*this);
1873 }
1874
1875 #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack)
1876
1877 void Sema::pushOpenMPFunctionRegion() {
1878   DSAStack->pushFunction();
1879 }
1880
1881 void Sema::popOpenMPFunctionRegion(const FunctionScopeInfo *OldFSI) {
1882   DSAStack->popFunction(OldFSI);
1883 }
1884
1885 static bool isOpenMPDeviceDelayedContext(Sema &S) {
1886   assert(S.LangOpts.OpenMP && S.LangOpts.OpenMPIsDevice &&
1887          "Expected OpenMP device compilation.");
1888   return !S.isInOpenMPTargetExecutionDirective() &&
1889          !S.isInOpenMPDeclareTargetContext();
1890 }
1891
1892 namespace {
1893 /// Status of the function emission on the host/device.
1894 enum class FunctionEmissionStatus {
1895   Emitted,
1896   Discarded,
1897   Unknown,
1898 };
1899 } // anonymous namespace
1900
1901 Sema::SemaDiagnosticBuilder Sema::diagIfOpenMPDeviceCode(SourceLocation Loc,
1902                                                          unsigned DiagID) {
1903   assert(LangOpts.OpenMP && LangOpts.OpenMPIsDevice &&
1904          "Expected OpenMP device compilation.");
1905
1906   FunctionDecl *FD = getCurFunctionDecl();
1907   SemaDiagnosticBuilder::Kind Kind = SemaDiagnosticBuilder::K_Nop;
1908   if (FD) {
1909     FunctionEmissionStatus FES = getEmissionStatus(FD);
1910     switch (FES) {
1911     case FunctionEmissionStatus::Emitted:
1912       Kind = SemaDiagnosticBuilder::K_Immediate;
1913       break;
1914     case FunctionEmissionStatus::Unknown:
1915       Kind = isOpenMPDeviceDelayedContext(*this)
1916                  ? SemaDiagnosticBuilder::K_Deferred
1917                  : SemaDiagnosticBuilder::K_Immediate;
1918       break;
1919     case FunctionEmissionStatus::TemplateDiscarded:
1920     case FunctionEmissionStatus::OMPDiscarded:
1921       Kind = SemaDiagnosticBuilder::K_Nop;
1922       break;
1923     case FunctionEmissionStatus::CUDADiscarded:
1924       llvm_unreachable("CUDADiscarded unexpected in OpenMP device compilation");
1925       break;
1926     }
1927   }
1928
1929   return SemaDiagnosticBuilder(Kind, Loc, DiagID, getCurFunctionDecl(), *this);
1930 }
1931
1932 Sema::SemaDiagnosticBuilder Sema::diagIfOpenMPHostCode(SourceLocation Loc,
1933                                                        unsigned DiagID) {
1934   assert(LangOpts.OpenMP && !LangOpts.OpenMPIsDevice &&
1935          "Expected OpenMP host compilation.");
1936   FunctionEmissionStatus FES = getEmissionStatus(getCurFunctionDecl());
1937   SemaDiagnosticBuilder::Kind Kind = SemaDiagnosticBuilder::K_Nop;
1938   switch (FES) {
1939   case FunctionEmissionStatus::Emitted:
1940     Kind = SemaDiagnosticBuilder::K_Immediate;
1941     break;
1942   case FunctionEmissionStatus::Unknown:
1943     Kind = SemaDiagnosticBuilder::K_Deferred;
1944     break;
1945   case FunctionEmissionStatus::TemplateDiscarded:
1946   case FunctionEmissionStatus::OMPDiscarded:
1947   case FunctionEmissionStatus::CUDADiscarded:
1948     Kind = SemaDiagnosticBuilder::K_Nop;
1949     break;
1950   }
1951
1952   return SemaDiagnosticBuilder(Kind, Loc, DiagID, getCurFunctionDecl(), *this);
1953 }
1954
1955 static OpenMPDefaultmapClauseKind
1956 getVariableCategoryFromDecl(const LangOptions &LO, const ValueDecl *VD) {
1957   if (LO.OpenMP <= 45) {
1958     if (VD->getType().getNonReferenceType()->isScalarType())
1959       return OMPC_DEFAULTMAP_scalar;
1960     return OMPC_DEFAULTMAP_aggregate;
1961   }
1962   if (VD->getType().getNonReferenceType()->isAnyPointerType())
1963     return OMPC_DEFAULTMAP_pointer;
1964   if (VD->getType().getNonReferenceType()->isScalarType())
1965     return OMPC_DEFAULTMAP_scalar;
1966   return OMPC_DEFAULTMAP_aggregate;
1967 }
1968
1969 bool Sema::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level,
1970                                  unsigned OpenMPCaptureLevel) const {
1971   assert(LangOpts.OpenMP && "OpenMP is not allowed");
1972
1973   ASTContext &Ctx = getASTContext();
1974   bool IsByRef = true;
1975
1976   // Find the directive that is associated with the provided scope.
1977   D = cast<ValueDecl>(D->getCanonicalDecl());
1978   QualType Ty = D->getType();
1979
1980   bool IsVariableUsedInMapClause = false;
1981   if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) {
1982     // This table summarizes how a given variable should be passed to the device
1983     // given its type and the clauses where it appears. This table is based on
1984     // the description in OpenMP 4.5 [2.10.4, target Construct] and
1985     // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses].
1986     //
1987     // =========================================================================
1988     // | type |  defaultmap   | pvt | first | is_device_ptr |    map   | res.  |
1989     // |      |(tofrom:scalar)|     |  pvt  |               |          |       |
1990     // =========================================================================
1991     // | scl  |               |     |       |       -       |          | bycopy|
1992     // | scl  |               |  -  |   x   |       -       |     -    | bycopy|
1993     // | scl  |               |  x  |   -   |       -       |     -    | null  |
1994     // | scl  |       x       |     |       |       -       |          | byref |
1995     // | scl  |       x       |  -  |   x   |       -       |     -    | bycopy|
1996     // | scl  |       x       |  x  |   -   |       -       |     -    | null  |
1997     // | scl  |               |  -  |   -   |       -       |     x    | byref |
1998     // | scl  |       x       |  -  |   -   |       -       |     x    | byref |
1999     //
2000     // | agg  |      n.a.     |     |       |       -       |          | byref |
2001     // | agg  |      n.a.     |  -  |   x   |       -       |     -    | byref |
2002     // | agg  |      n.a.     |  x  |   -   |       -       |     -    | null  |
2003     // | agg  |      n.a.     |  -  |   -   |       -       |     x    | byref |
2004     // | agg  |      n.a.     |  -  |   -   |       -       |    x[]   | byref |
2005     //
2006     // | ptr  |      n.a.     |     |       |       -       |          | bycopy|
2007     // | ptr  |      n.a.     |  -  |   x   |       -       |     -    | bycopy|
2008     // | ptr  |      n.a.     |  x  |   -   |       -       |     -    | null  |
2009     // | ptr  |      n.a.     |  -  |   -   |       -       |     x    | byref |
2010     // | ptr  |      n.a.     |  -  |   -   |       -       |    x[]   | bycopy|
2011     // | ptr  |      n.a.     |  -  |   -   |       x       |          | bycopy|
2012     // | ptr  |      n.a.     |  -  |   -   |       x       |     x    | bycopy|
2013     // | ptr  |      n.a.     |  -  |   -   |       x       |    x[]   | bycopy|
2014     // =========================================================================
2015     // Legend:
2016     //  scl - scalar
2017     //  ptr - pointer
2018     //  agg - aggregate
2019     //  x - applies
2020     //  - - invalid in this combination
2021     //  [] - mapped with an array section
2022     //  byref - should be mapped by reference
2023     //  byval - should be mapped by value
2024     //  null - initialize a local variable to null on the device
2025     //
2026     // Observations:
2027     //  - All scalar declarations that show up in a map clause have to be passed
2028     //    by reference, because they may have been mapped in the enclosing data
2029     //    environment.
2030     //  - If the scalar value does not fit the size of uintptr, it has to be
2031     //    passed by reference, regardless the result in the table above.
2032     //  - For pointers mapped by value that have either an implicit map or an
2033     //    array section, the runtime library may pass the NULL value to the
2034     //    device instead of the value passed to it by the compiler.
2035
2036     if (Ty->isReferenceType())
2037       Ty = Ty->castAs<ReferenceType>()->getPointeeType();
2038
2039     // Locate map clauses and see if the variable being captured is referred to
2040     // in any of those clauses. Here we only care about variables, not fields,
2041     // because fields are part of aggregates.
2042     bool IsVariableAssociatedWithSection = false;
2043
2044     DSAStack->checkMappableExprComponentListsForDeclAtLevel(
2045         D, Level,
2046         [&IsVariableUsedInMapClause, &IsVariableAssociatedWithSection, D](
2047             OMPClauseMappableExprCommon::MappableExprComponentListRef
2048                 MapExprComponents,
2049             OpenMPClauseKind WhereFoundClauseKind) {
2050           // Only the map clause information influences how a variable is
2051           // captured. E.g. is_device_ptr does not require changing the default
2052           // behavior.
2053           if (WhereFoundClauseKind != OMPC_map)
2054             return false;
2055
2056           auto EI = MapExprComponents.rbegin();
2057           auto EE = MapExprComponents.rend();
2058
2059           assert(EI != EE && "Invalid map expression!");
2060
2061           if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
2062             IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
2063
2064           ++EI;
2065           if (EI == EE)
2066             return false;
2067
2068           if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
2069               isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
2070               isa<MemberExpr>(EI->getAssociatedExpression()) ||
2071               isa<OMPArrayShapingExpr>(EI->getAssociatedExpression())) {
2072             IsVariableAssociatedWithSection = true;
2073             // There is nothing more we need to know about this variable.
2074             return true;
2075           }
2076
2077           // Keep looking for more map info.
2078           return false;
2079         });
2080
2081     if (IsVariableUsedInMapClause) {
2082       // If variable is identified in a map clause it is always captured by
2083       // reference except if it is a pointer that is dereferenced somehow.
2084       IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
2085     } else {
2086       // By default, all the data that has a scalar type is mapped by copy
2087       // (except for reduction variables).
2088       // Defaultmap scalar is mutual exclusive to defaultmap pointer
2089       IsByRef = (DSAStack->isForceCaptureByReferenceInTargetExecutable() &&
2090                  !Ty->isAnyPointerType()) ||
2091                 !Ty->isScalarType() ||
2092                 DSAStack->isDefaultmapCapturedByRef(
2093                     Level, getVariableCategoryFromDecl(LangOpts, D)) ||
2094                 DSAStack->hasExplicitDSA(
2095                     D,
2096                     [](OpenMPClauseKind K, bool AppliedToPointee) {
2097                       return K == OMPC_reduction && !AppliedToPointee;
2098                     },
2099                     Level);
2100     }
2101   }
2102
2103   if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
2104     IsByRef =
2105         ((IsVariableUsedInMapClause &&
2106           DSAStack->getCaptureRegion(Level, OpenMPCaptureLevel) ==
2107               OMPD_target) ||
2108          !(DSAStack->hasExplicitDSA(
2109                D,
2110                [](OpenMPClauseKind K, bool AppliedToPointee) -> bool {
2111                  return K == OMPC_firstprivate ||
2112                         (K == OMPC_reduction && AppliedToPointee);
2113                },
2114                Level, /*NotLastprivate=*/true) ||
2115            DSAStack->isUsesAllocatorsDecl(Level, D))) &&
2116         // If the variable is artificial and must be captured by value - try to
2117         // capture by value.
2118         !(isa<OMPCapturedExprDecl>(D) && !D->hasAttr<OMPCaptureNoInitAttr>() &&
2119           !cast<OMPCapturedExprDecl>(D)->getInit()->isGLValue()) &&
2120         // If the variable is implicitly firstprivate and scalar - capture by
2121         // copy
2122         !(DSAStack->getDefaultDSA() == DSA_firstprivate &&
2123           !DSAStack->hasExplicitDSA(
2124               D, [](OpenMPClauseKind K, bool) { return K != OMPC_unknown; },
2125               Level) &&
2126           !DSAStack->isLoopControlVariable(D, Level).first);
2127   }
2128
2129   // When passing data by copy, we need to make sure it fits the uintptr size
2130   // and alignment, because the runtime library only deals with uintptr types.
2131   // If it does not fit the uintptr size, we need to pass the data by reference
2132   // instead.
2133   if (!IsByRef &&
2134       (Ctx.getTypeSizeInChars(Ty) >
2135            Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
2136        Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
2137     IsByRef = true;
2138   }
2139
2140   return IsByRef;
2141 }
2142
2143 unsigned Sema::getOpenMPNestingLevel() const {
2144   assert(getLangOpts().OpenMP);
2145   return DSAStack->getNestingLevel();
2146 }
2147
2148 bool Sema::isInOpenMPTargetExecutionDirective() const {
2149   return (isOpenMPTargetExecutionDirective(DSAStack->getCurrentDirective()) &&
2150           !DSAStack->isClauseParsingMode()) ||
2151          DSAStack->hasDirective(
2152              [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
2153                 SourceLocation) -> bool {
2154                return isOpenMPTargetExecutionDirective(K);
2155              },
2156              false);
2157 }
2158
2159 VarDecl *Sema::isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo,
2160                                     unsigned StopAt) {
2161   assert(LangOpts.OpenMP && "OpenMP is not allowed");
2162   D = getCanonicalDecl(D);
2163
2164   auto *VD = dyn_cast<VarDecl>(D);
2165   // Do not capture constexpr variables.
2166   if (VD && VD->isConstexpr())
2167     return nullptr;
2168
2169   // If we want to determine whether the variable should be captured from the
2170   // perspective of the current capturing scope, and we've already left all the
2171   // capturing scopes of the top directive on the stack, check from the
2172   // perspective of its parent directive (if any) instead.
2173   DSAStackTy::ParentDirectiveScope InParentDirectiveRAII(
2174       *DSAStack, CheckScopeInfo && DSAStack->isBodyComplete());
2175
2176   // If we are attempting to capture a global variable in a directive with
2177   // 'target' we return true so that this global is also mapped to the device.
2178   //
2179   if (VD && !VD->hasLocalStorage() &&
2180       (getCurCapturedRegion() || getCurBlock() || getCurLambda())) {
2181     if (isInOpenMPDeclareTargetContext()) {
2182       // Try to mark variable as declare target if it is used in capturing
2183       // regions.
2184       if (LangOpts.OpenMP <= 45 &&
2185           !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
2186         checkDeclIsAllowedInOpenMPTarget(nullptr, VD);
2187       return nullptr;
2188     }
2189     if (isInOpenMPTargetExecutionDirective()) {
2190       // If the declaration is enclosed in a 'declare target' directive,
2191       // then it should not be captured.
2192       //
2193       if (OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
2194         return nullptr;
2195       CapturedRegionScopeInfo *CSI = nullptr;
2196       for (FunctionScopeInfo *FSI : llvm::drop_begin(
2197                llvm::reverse(FunctionScopes),
2198                CheckScopeInfo ? (FunctionScopes.size() - (StopAt + 1)) : 0)) {
2199         if (!isa<CapturingScopeInfo>(FSI))
2200           return nullptr;
2201         if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(FSI))
2202           if (RSI->CapRegionKind == CR_OpenMP) {
2203             CSI = RSI;
2204             break;
2205           }
2206       }
2207       assert(CSI && "Failed to find CapturedRegionScopeInfo");
2208       SmallVector<OpenMPDirectiveKind, 4> Regions;
2209       getOpenMPCaptureRegions(Regions,
2210                               DSAStack->getDirective(CSI->OpenMPLevel));
2211       if (Regions[CSI->OpenMPCaptureLevel] != OMPD_task)
2212         return VD;
2213     }
2214   }
2215
2216   if (CheckScopeInfo) {
2217     bool OpenMPFound = false;
2218     for (unsigned I = StopAt + 1; I > 0; --I) {
2219       FunctionScopeInfo *FSI = FunctionScopes[I - 1];
2220       if(!isa<CapturingScopeInfo>(FSI))
2221         return nullptr;
2222       if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(FSI))
2223         if (RSI->CapRegionKind == CR_OpenMP) {
2224           OpenMPFound = true;
2225           break;
2226         }
2227     }
2228     if (!OpenMPFound)
2229       return nullptr;
2230   }
2231
2232   if (DSAStack->getCurrentDirective() != OMPD_unknown &&
2233       (!DSAStack->isClauseParsingMode() ||
2234        DSAStack->getParentDirective() != OMPD_unknown)) {
2235     auto &&Info = DSAStack->isLoopControlVariable(D);
2236     if (Info.first ||
2237         (VD && VD->hasLocalStorage() &&
2238          isImplicitOrExplicitTaskingRegion(DSAStack->getCurrentDirective())) ||
2239         (VD && DSAStack->isForceVarCapturing()))
2240       return VD ? VD : Info.second;
2241     DSAStackTy::DSAVarData DVarTop =
2242         DSAStack->getTopDSA(D, DSAStack->isClauseParsingMode());
2243     if (DVarTop.CKind != OMPC_unknown && isOpenMPPrivate(DVarTop.CKind) &&
2244         (!VD || VD->hasLocalStorage() || !DVarTop.AppliedToPointee))
2245       return VD ? VD : cast<VarDecl>(DVarTop.PrivateCopy->getDecl());
2246     // Threadprivate variables must not be captured.
2247     if (isOpenMPThreadPrivate(DVarTop.CKind))
2248       return nullptr;
2249     // The variable is not private or it is the variable in the directive with
2250     // default(none) clause and not used in any clause.
2251     DSAStackTy::DSAVarData DVarPrivate = DSAStack->hasDSA(
2252         D,
2253         [](OpenMPClauseKind C, bool AppliedToPointee) {
2254           return isOpenMPPrivate(C) && !AppliedToPointee;
2255         },
2256         [](OpenMPDirectiveKind) { return true; },
2257         DSAStack->isClauseParsingMode());
2258     // Global shared must not be captured.
2259     if (VD && !VD->hasLocalStorage() && DVarPrivate.CKind == OMPC_unknown &&
2260         ((DSAStack->getDefaultDSA() != DSA_none &&
2261           DSAStack->getDefaultDSA() != DSA_firstprivate) ||
2262          DVarTop.CKind == OMPC_shared))
2263       return nullptr;
2264     if (DVarPrivate.CKind != OMPC_unknown ||
2265         (VD && (DSAStack->getDefaultDSA() == DSA_none ||
2266                 DSAStack->getDefaultDSA() == DSA_firstprivate)))
2267       return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
2268   }
2269   return nullptr;
2270 }
2271
2272 void Sema::adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
2273                                         unsigned Level) const {
2274   FunctionScopesIndex -= getOpenMPCaptureLevels(DSAStack->getDirective(Level));
2275 }
2276
2277 void Sema::startOpenMPLoop() {
2278   assert(LangOpts.OpenMP && "OpenMP must be enabled.");
2279   if (isOpenMPLoopDirective(DSAStack->getCurrentDirective()))
2280     DSAStack->loopInit();
2281 }
2282
2283 void Sema::startOpenMPCXXRangeFor() {
2284   assert(LangOpts.OpenMP && "OpenMP must be enabled.");
2285   if (isOpenMPLoopDirective(DSAStack->getCurrentDirective())) {
2286     DSAStack->resetPossibleLoopCounter();
2287     DSAStack->loopStart();
2288   }
2289 }
2290
2291 OpenMPClauseKind Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level,
2292                                            unsigned CapLevel) const {
2293   assert(LangOpts.OpenMP && "OpenMP is not allowed");
2294   if (DSAStack->hasExplicitDirective(
2295           [](OpenMPDirectiveKind K) { return isOpenMPTaskingDirective(K); },
2296           Level)) {
2297     bool IsTriviallyCopyable =
2298         D->getType().getNonReferenceType().isTriviallyCopyableType(Context) &&
2299         !D->getType()
2300              .getNonReferenceType()
2301              .getCanonicalType()
2302              ->getAsCXXRecordDecl();
2303     OpenMPDirectiveKind DKind = DSAStack->getDirective(Level);
2304     SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
2305     getOpenMPCaptureRegions(CaptureRegions, DKind);
2306     if (isOpenMPTaskingDirective(CaptureRegions[CapLevel]) &&
2307         (IsTriviallyCopyable ||
2308          !isOpenMPTaskLoopDirective(CaptureRegions[CapLevel]))) {
2309       if (DSAStack->hasExplicitDSA(
2310               D,
2311               [](OpenMPClauseKind K, bool) { return K == OMPC_firstprivate; },
2312               Level, /*NotLastprivate=*/true))
2313         return OMPC_firstprivate;
2314       DSAStackTy::DSAVarData DVar = DSAStack->getImplicitDSA(D, Level);
2315       if (DVar.CKind != OMPC_shared &&
2316           !DSAStack->isLoopControlVariable(D, Level).first && !DVar.RefExpr) {
2317         DSAStack->addImplicitTaskFirstprivate(Level, D);
2318         return OMPC_firstprivate;
2319       }
2320     }
2321   }
2322   if (isOpenMPLoopDirective(DSAStack->getCurrentDirective())) {
2323     if (DSAStack->getAssociatedLoops() > 0 &&
2324         !DSAStack->isLoopStarted()) {
2325       DSAStack->resetPossibleLoopCounter(D);
2326       DSAStack->loopStart();
2327       return OMPC_private;
2328     }
2329     if ((DSAStack->getPossiblyLoopCunter() == D->getCanonicalDecl() ||
2330          DSAStack->isLoopControlVariable(D).first) &&
2331         !DSAStack->hasExplicitDSA(
2332             D, [](OpenMPClauseKind K, bool) { return K != OMPC_private; },
2333             Level) &&
2334         !isOpenMPSimdDirective(DSAStack->getCurrentDirective()))
2335       return OMPC_private;
2336   }
2337   if (const auto *VD = dyn_cast<VarDecl>(D)) {
2338     if (DSAStack->isThreadPrivate(const_cast<VarDecl *>(VD)) &&
2339         DSAStack->isForceVarCapturing() &&
2340         !DSAStack->hasExplicitDSA(
2341             D, [](OpenMPClauseKind K, bool) { return K == OMPC_copyin; },
2342             Level))
2343       return OMPC_private;
2344   }
2345   // User-defined allocators are private since they must be defined in the
2346   // context of target region.
2347   if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level) &&
2348       DSAStack->isUsesAllocatorsDecl(Level, D).getValueOr(
2349           DSAStackTy::UsesAllocatorsDeclKind::AllocatorTrait) ==
2350           DSAStackTy::UsesAllocatorsDeclKind::UserDefinedAllocator)
2351     return OMPC_private;
2352   return (DSAStack->hasExplicitDSA(
2353               D, [](OpenMPClauseKind K, bool) { return K == OMPC_private; },
2354               Level) ||
2355           (DSAStack->isClauseParsingMode() &&
2356            DSAStack->getClauseParsingMode() == OMPC_private) ||
2357           // Consider taskgroup reduction descriptor variable a private
2358           // to avoid possible capture in the region.
2359           (DSAStack->hasExplicitDirective(
2360                [](OpenMPDirectiveKind K) {
2361                  return K == OMPD_taskgroup ||
2362                         ((isOpenMPParallelDirective(K) ||
2363                           isOpenMPWorksharingDirective(K)) &&
2364                          !isOpenMPSimdDirective(K));
2365                },
2366                Level) &&
2367            DSAStack->isTaskgroupReductionRef(D, Level)))
2368              ? OMPC_private
2369              : OMPC_unknown;
2370 }
2371
2372 void Sema::setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D,
2373                                 unsigned Level) {
2374   assert(LangOpts.OpenMP && "OpenMP is not allowed");
2375   D = getCanonicalDecl(D);
2376   OpenMPClauseKind OMPC = OMPC_unknown;
2377   for (unsigned I = DSAStack->getNestingLevel() + 1; I > Level; --I) {
2378     const unsigned NewLevel = I - 1;
2379     if (DSAStack->hasExplicitDSA(
2380             D,
2381             [&OMPC](const OpenMPClauseKind K, bool AppliedToPointee) {
2382               if (isOpenMPPrivate(K) && !AppliedToPointee) {
2383                 OMPC = K;
2384                 return true;
2385               }
2386               return false;
2387             },
2388             NewLevel))
2389       break;
2390     if (DSAStack->checkMappableExprComponentListsForDeclAtLevel(
2391             D, NewLevel,
2392             [](OMPClauseMappableExprCommon::MappableExprComponentListRef,
2393                OpenMPClauseKind) { return true; })) {
2394       OMPC = OMPC_map;
2395       break;
2396     }
2397     if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
2398                                        NewLevel)) {
2399       OMPC = OMPC_map;
2400       if (DSAStack->mustBeFirstprivateAtLevel(
2401               NewLevel, getVariableCategoryFromDecl(LangOpts, D)))
2402         OMPC = OMPC_firstprivate;
2403       break;
2404     }
2405   }
2406   if (OMPC != OMPC_unknown)
2407     FD->addAttr(OMPCaptureKindAttr::CreateImplicit(Context, unsigned(OMPC)));
2408 }
2409
2410 bool Sema::isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,
2411                                       unsigned CaptureLevel) const {
2412   assert(LangOpts.OpenMP && "OpenMP is not allowed");
2413   // Return true if the current level is no longer enclosed in a target region.
2414
2415   SmallVector<OpenMPDirectiveKind, 4> Regions;
2416   getOpenMPCaptureRegions(Regions, DSAStack->getDirective(Level));
2417   const auto *VD = dyn_cast<VarDecl>(D);
2418   return VD && !VD->hasLocalStorage() &&
2419          DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
2420                                         Level) &&
2421          Regions[CaptureLevel] != OMPD_task;
2422 }
2423
2424 bool Sema::isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level,
2425                                       unsigned CaptureLevel) const {
2426   assert(LangOpts.OpenMP && "OpenMP is not allowed");
2427   // Return true if the current level is no longer enclosed in a target region.
2428
2429   if (const auto *VD = dyn_cast<VarDecl>(D)) {
2430     if (!VD->hasLocalStorage()) {
2431       if (isInOpenMPTargetExecutionDirective())
2432         return true;
2433       DSAStackTy::DSAVarData TopDVar =
2434           DSAStack->getTopDSA(D, /*FromParent=*/false);
2435       unsigned NumLevels =
2436           getOpenMPCaptureLevels(DSAStack->getDirective(Level));
2437       if (Level == 0)
2438         return (NumLevels == CaptureLevel + 1) && TopDVar.CKind != OMPC_shared;
2439       do {
2440         --Level;
2441         DSAStackTy::DSAVarData DVar = DSAStack->getImplicitDSA(D, Level);
2442         if (DVar.CKind != OMPC_shared)
2443           return true;
2444       } while (Level > 0);
2445     }
2446   }
2447   return true;
2448 }
2449
2450 void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; }
2451
2452 void Sema::ActOnOpenMPBeginDeclareVariant(SourceLocation Loc,
2453                                           OMPTraitInfo &TI) {
2454   OMPDeclareVariantScopes.push_back(OMPDeclareVariantScope(TI));
2455 }
2456
2457 void Sema::ActOnOpenMPEndDeclareVariant() {
2458   assert(isInOpenMPDeclareVariantScope() &&
2459          "Not in OpenMP declare variant scope!");
2460
2461   OMPDeclareVariantScopes.pop_back();
2462 }
2463
2464 void Sema::finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
2465                                          const FunctionDecl *Callee,
2466                                          SourceLocation Loc) {
2467   assert(LangOpts.OpenMP && "Expected OpenMP compilation mode.");
2468   Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
2469       OMPDeclareTargetDeclAttr::getDeviceType(Caller->getMostRecentDecl());
2470   // Ignore host functions during device analyzis.
2471   if (LangOpts.OpenMPIsDevice && DevTy &&
2472       *DevTy == OMPDeclareTargetDeclAttr::DT_Host)
2473     return;
2474   // Ignore nohost functions during host analyzis.
2475   if (!LangOpts.OpenMPIsDevice && DevTy &&
2476       *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
2477     return;
2478   const FunctionDecl *FD = Callee->getMostRecentDecl();
2479   DevTy = OMPDeclareTargetDeclAttr::getDeviceType(FD);
2480   if (LangOpts.OpenMPIsDevice && DevTy &&
2481       *DevTy == OMPDeclareTargetDeclAttr::DT_Host) {
2482     // Diagnose host function called during device codegen.
2483     StringRef HostDevTy =
2484         getOpenMPSimpleClauseTypeName(OMPC_device_type, OMPC_DEVICE_TYPE_host);
2485     Diag(Loc, diag::err_omp_wrong_device_function_call) << HostDevTy << 0;
2486     Diag(*OMPDeclareTargetDeclAttr::getLocation(FD),
2487          diag::note_omp_marked_device_type_here)
2488         << HostDevTy;
2489     return;
2490   }
2491       if (!LangOpts.OpenMPIsDevice && DevTy &&
2492           *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost) {
2493         // Diagnose nohost function called during host codegen.
2494         StringRef NoHostDevTy = getOpenMPSimpleClauseTypeName(
2495             OMPC_device_type, OMPC_DEVICE_TYPE_nohost);
2496         Diag(Loc, diag::err_omp_wrong_device_function_call) << NoHostDevTy << 1;
2497         Diag(*OMPDeclareTargetDeclAttr::getLocation(FD),
2498              diag::note_omp_marked_device_type_here)
2499             << NoHostDevTy;
2500       }
2501 }
2502
2503 void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
2504                                const DeclarationNameInfo &DirName,
2505                                Scope *CurScope, SourceLocation Loc) {
2506   DSAStack->push(DKind, DirName, CurScope, Loc);
2507   PushExpressionEvaluationContext(
2508       ExpressionEvaluationContext::PotentiallyEvaluated);
2509 }
2510
2511 void Sema::StartOpenMPClause(OpenMPClauseKind K) {
2512   DSAStack->setClauseParsingMode(K);
2513 }
2514
2515 void Sema::EndOpenMPClause() {
2516   DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown);
2517 }
2518
2519 static std::pair<ValueDecl *, bool>
2520 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
2521                SourceRange &ERange, bool AllowArraySection = false);
2522
2523 /// Check consistency of the reduction clauses.
2524 static void checkReductionClauses(Sema &S, DSAStackTy *Stack,
2525                                   ArrayRef<OMPClause *> Clauses) {
2526   bool InscanFound = false;
2527   SourceLocation InscanLoc;
2528   // OpenMP 5.0, 2.19.5.4 reduction Clause, Restrictions.
2529   // A reduction clause without the inscan reduction-modifier may not appear on
2530   // a construct on which a reduction clause with the inscan reduction-modifier
2531   // appears.
2532   for (OMPClause *C : Clauses) {
2533     if (C->getClauseKind() != OMPC_reduction)
2534       continue;
2535     auto *RC = cast<OMPReductionClause>(C);
2536     if (RC->getModifier() == OMPC_REDUCTION_inscan) {
2537       InscanFound = true;
2538       InscanLoc = RC->getModifierLoc();
2539       continue;
2540     }
2541     if (RC->getModifier() == OMPC_REDUCTION_task) {
2542       // OpenMP 5.0, 2.19.5.4 reduction Clause.
2543       // A reduction clause with the task reduction-modifier may only appear on
2544       // a parallel construct, a worksharing construct or a combined or
2545       // composite construct for which any of the aforementioned constructs is a
2546       // constituent construct and simd or loop are not constituent constructs.
2547       OpenMPDirectiveKind CurDir = Stack->getCurrentDirective();
2548       if (!(isOpenMPParallelDirective(CurDir) ||
2549             isOpenMPWorksharingDirective(CurDir)) ||
2550           isOpenMPSimdDirective(CurDir))
2551         S.Diag(RC->getModifierLoc(),
2552                diag::err_omp_reduction_task_not_parallel_or_worksharing);
2553       continue;
2554     }
2555   }
2556   if (InscanFound) {
2557     for (OMPClause *C : Clauses) {
2558       if (C->getClauseKind() != OMPC_reduction)
2559         continue;
2560       auto *RC = cast<OMPReductionClause>(C);
2561       if (RC->getModifier() != OMPC_REDUCTION_inscan) {
2562         S.Diag(RC->getModifier() == OMPC_REDUCTION_unknown
2563                    ? RC->getBeginLoc()
2564                    : RC->getModifierLoc(),
2565                diag::err_omp_inscan_reduction_expected);
2566         S.Diag(InscanLoc, diag::note_omp_previous_inscan_reduction);
2567         continue;
2568       }
2569       for (Expr *Ref : RC->varlists()) {
2570         assert(Ref && "NULL expr in OpenMP nontemporal clause.");
2571         SourceLocation ELoc;
2572         SourceRange ERange;
2573         Expr *SimpleRefExpr = Ref;
2574         auto Res = getPrivateItem(S, SimpleRefExpr, ELoc, ERange,
2575                                   /*AllowArraySection=*/true);
2576         ValueDecl *D = Res.first;
2577         if (!D)
2578           continue;
2579         if (!Stack->isUsedInScanDirective(getCanonicalDecl(D))) {
2580           S.Diag(Ref->getExprLoc(),
2581                  diag::err_omp_reduction_not_inclusive_exclusive)
2582               << Ref->getSourceRange();
2583         }
2584       }
2585     }
2586   }
2587 }
2588
2589 static void checkAllocateClauses(Sema &S, DSAStackTy *Stack,
2590                                  ArrayRef<OMPClause *> Clauses);
2591 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
2592                                  bool WithInit);
2593
2594 static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack,
2595                               const ValueDecl *D,
2596                               const DSAStackTy::DSAVarData &DVar,
2597                               bool IsLoopIterVar = false);
2598
2599 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
2600   // OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
2601   //  A variable of class type (or array thereof) that appears in a lastprivate
2602   //  clause requires an accessible, unambiguous default constructor for the
2603   //  class type, unless the list item is also specified in a firstprivate
2604   //  clause.
2605   if (const auto *D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
2606     for (OMPClause *C : D->clauses()) {
2607       if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
2608         SmallVector<Expr *, 8> PrivateCopies;
2609         for (Expr *DE : Clause->varlists()) {
2610           if (DE->isValueDependent() || DE->isTypeDependent()) {
2611             PrivateCopies.push_back(nullptr);
2612             continue;
2613           }
2614           auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
2615           auto *VD = cast<VarDecl>(DRE->getDecl());
2616           QualType Type = VD->getType().getNonReferenceType();
2617           const DSAStackTy::DSAVarData DVar =
2618               DSAStack->getTopDSA(VD, /*FromParent=*/false);
2619           if (DVar.CKind == OMPC_lastprivate) {
2620             // Generate helper private variable and initialize it with the
2621             // default value. The address of the original variable is replaced
2622             // by the address of the new private variable in CodeGen. This new
2623             // variable is not added to IdResolver, so the code in the OpenMP
2624             // region uses original variable for proper diagnostics.
2625             VarDecl *VDPrivate = buildVarDecl(
2626                 *this, DE->getExprLoc(), Type.getUnqualifiedType(),
2627                 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr, DRE);
2628             ActOnUninitializedDecl(VDPrivate);
2629             if (VDPrivate->isInvalidDecl()) {
2630               PrivateCopies.push_back(nullptr);
2631               continue;
2632             }
2633             PrivateCopies.push_back(buildDeclRefExpr(
2634                 *this, VDPrivate, DE->getType(), DE->getExprLoc()));
2635           } else {
2636             // The variable is also a firstprivate, so initialization sequence
2637             // for private copy is generated already.
2638             PrivateCopies.push_back(nullptr);
2639           }
2640         }
2641         Clause->setPrivateCopies(PrivateCopies);
2642         continue;
2643       }
2644       // Finalize nontemporal clause by handling private copies, if any.
2645       if (auto *Clause = dyn_cast<OMPNontemporalClause>(C)) {
2646         SmallVector<Expr *, 8> PrivateRefs;
2647         for (Expr *RefExpr : Clause->varlists()) {
2648           assert(RefExpr && "NULL expr in OpenMP nontemporal clause.");
2649           SourceLocation ELoc;
2650           SourceRange ERange;
2651           Expr *SimpleRefExpr = RefExpr;
2652           auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
2653           if (Res.second)
2654             // It will be analyzed later.
2655             PrivateRefs.push_back(RefExpr);
2656           ValueDecl *D = Res.first;
2657           if (!D)
2658             continue;
2659
2660           const DSAStackTy::DSAVarData DVar =
2661               DSAStack->getTopDSA(D, /*FromParent=*/false);
2662           PrivateRefs.push_back(DVar.PrivateCopy ? DVar.PrivateCopy
2663                                                  : SimpleRefExpr);
2664         }
2665         Clause->setPrivateRefs(PrivateRefs);
2666         continue;
2667       }
2668       if (auto *Clause = dyn_cast<OMPUsesAllocatorsClause>(C)) {
2669         for (unsigned I = 0, E = Clause->getNumberOfAllocators(); I < E; ++I) {
2670           OMPUsesAllocatorsClause::Data D = Clause->getAllocatorData(I);
2671           auto *DRE = dyn_cast<DeclRefExpr>(D.Allocator->IgnoreParenImpCasts());
2672           if (!DRE)
2673             continue;
2674           ValueDecl *VD = DRE->getDecl();
2675           if (!VD || !isa<VarDecl>(VD))
2676             continue;
2677           DSAStackTy::DSAVarData DVar =
2678               DSAStack->getTopDSA(VD, /*FromParent=*/false);
2679           // OpenMP [2.12.5, target Construct]
2680           // Memory allocators that appear in a uses_allocators clause cannot
2681           // appear in other data-sharing attribute clauses or data-mapping
2682           // attribute clauses in the same construct.
2683           Expr *MapExpr = nullptr;
2684           if (DVar.RefExpr ||
2685               DSAStack->checkMappableExprComponentListsForDecl(
2686                   VD, /*CurrentRegionOnly=*/true,
2687                   [VD, &MapExpr](
2688                       OMPClauseMappableExprCommon::MappableExprComponentListRef
2689                           MapExprComponents,
2690                       OpenMPClauseKind C) {
2691                     auto MI = MapExprComponents.rbegin();
2692                     auto ME = MapExprComponents.rend();
2693                     if (MI != ME &&
2694                         MI->getAssociatedDeclaration()->getCanonicalDecl() ==
2695                             VD->getCanonicalDecl()) {
2696                       MapExpr = MI->getAssociatedExpression();
2697                       return true;
2698                     }
2699                     return false;
2700                   })) {
2701             Diag(D.Allocator->getExprLoc(),
2702                  diag::err_omp_allocator_used_in_clauses)
2703                 << D.Allocator->getSourceRange();
2704             if (DVar.RefExpr)
2705               reportOriginalDsa(*this, DSAStack, VD, DVar);
2706             else
2707               Diag(MapExpr->getExprLoc(), diag::note_used_here)
2708                   << MapExpr->getSourceRange();
2709           }
2710         }
2711         continue;
2712       }
2713     }
2714     // Check allocate clauses.
2715     if (!CurContext->isDependentContext())
2716       checkAllocateClauses(*this, DSAStack, D->clauses());
2717     checkReductionClauses(*this, DSAStack, D->clauses());
2718   }
2719
2720   DSAStack->pop();
2721   DiscardCleanupsInEvaluationContext();
2722   PopExpressionEvaluationContext();
2723 }
2724
2725 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
2726                                      Expr *NumIterations, Sema &SemaRef,
2727                                      Scope *S, DSAStackTy *Stack);
2728
2729 namespace {
2730
2731 class VarDeclFilterCCC final : public CorrectionCandidateCallback {
2732 private:
2733   Sema &SemaRef;
2734
2735 public:
2736   explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
2737   bool ValidateCandidate(const TypoCorrection &Candidate) override {
2738     NamedDecl *ND = Candidate.getCorrectionDecl();
2739     if (const auto *VD = dyn_cast_or_null<VarDecl>(ND)) {
2740       return VD->hasGlobalStorage() &&
2741              SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
2742                                    SemaRef.getCurScope());
2743     }
2744     return false;
2745   }
2746
2747   std::unique_ptr<CorrectionCandidateCallback> clone() override {
2748     return std::make_unique<VarDeclFilterCCC>(*this);
2749   }
2750
2751 };
2752
2753 class VarOrFuncDeclFilterCCC final : public CorrectionCandidateCallback {
2754 private:
2755   Sema &SemaRef;
2756
2757 public:
2758   explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
2759   bool ValidateCandidate(const TypoCorrection &Candidate) override {
2760     NamedDecl *ND = Candidate.getCorrectionDecl();
2761     if (ND && ((isa<VarDecl>(ND) && ND->getKind() == Decl::Var) ||
2762                isa<FunctionDecl>(ND))) {
2763       return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
2764                                    SemaRef.getCurScope());
2765     }
2766     return false;
2767   }
2768
2769   std::unique_ptr<CorrectionCandidateCallback> clone() override {
2770     return std::make_unique<VarOrFuncDeclFilterCCC>(*this);
2771   }
2772 };
2773
2774 } // namespace
2775
2776 ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
2777                                          CXXScopeSpec &ScopeSpec,
2778                                          const DeclarationNameInfo &Id,
2779                                          OpenMPDirectiveKind Kind) {
2780   LookupResult Lookup(*this, Id, LookupOrdinaryName);
2781   LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
2782
2783   if (Lookup.isAmbiguous())
2784     return ExprError();
2785
2786   VarDecl *VD;
2787   if (!Lookup.isSingleResult()) {
2788     VarDeclFilterCCC CCC(*this);
2789     if (TypoCorrection Corrected =
2790             CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr, CCC,
2791                         CTK_ErrorRecovery)) {
2792       diagnoseTypo(Corrected,
2793                    PDiag(Lookup.empty()
2794                              ? diag::err_undeclared_var_use_suggest
2795                              : diag::err_omp_expected_var_arg_suggest)
2796                        << Id.getName());
2797       VD = Corrected.getCorrectionDeclAs<VarDecl>();
2798     } else {
2799       Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
2800                                        : diag::err_omp_expected_var_arg)
2801           << Id.getName();
2802       return ExprError();
2803     }
2804   } else if (!(VD = Lookup.getAsSingle<VarDecl>())) {
2805     Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
2806     Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
2807     return ExprError();
2808   }
2809   Lookup.suppressDiagnostics();
2810
2811   // OpenMP [2.9.2, Syntax, C/C++]
2812   //   Variables must be file-scope, namespace-scope, or static block-scope.
2813   if (Kind == OMPD_threadprivate && !VD->hasGlobalStorage()) {
2814     Diag(Id.getLoc(), diag::err_omp_global_var_arg)
2815         << getOpenMPDirectiveName(Kind) << !VD->isStaticLocal();
2816     bool IsDecl =
2817         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2818     Diag(VD->getLocation(),
2819          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2820         << VD;
2821     return ExprError();
2822   }
2823
2824   VarDecl *CanonicalVD = VD->getCanonicalDecl();
2825   NamedDecl *ND = CanonicalVD;
2826   // OpenMP [2.9.2, Restrictions, C/C++, p.2]
2827   //   A threadprivate directive for file-scope variables must appear outside
2828   //   any definition or declaration.
2829   if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
2830       !getCurLexicalContext()->isTranslationUnit()) {
2831     Diag(Id.getLoc(), diag::err_omp_var_scope)
2832         << getOpenMPDirectiveName(Kind) << VD;
2833     bool IsDecl =
2834         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2835     Diag(VD->getLocation(),
2836          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2837         << VD;
2838     return ExprError();
2839   }
2840   // OpenMP [2.9.2, Restrictions, C/C++, p.3]
2841   //   A threadprivate directive for static class member variables must appear
2842   //   in the class definition, in the same scope in which the member
2843   //   variables are declared.
2844   if (CanonicalVD->isStaticDataMember() &&
2845       !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
2846     Diag(Id.getLoc(), diag::err_omp_var_scope)
2847         << getOpenMPDirectiveName(Kind) << VD;
2848     bool IsDecl =
2849         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2850     Diag(VD->getLocation(),
2851          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2852         << VD;
2853     return ExprError();
2854   }
2855   // OpenMP [2.9.2, Restrictions, C/C++, p.4]
2856   //   A threadprivate directive for namespace-scope variables must appear
2857   //   outside any definition or declaration other than the namespace
2858   //   definition itself.
2859   if (CanonicalVD->getDeclContext()->isNamespace() &&
2860       (!getCurLexicalContext()->isFileContext() ||
2861        !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
2862     Diag(Id.getLoc(), diag::err_omp_var_scope)
2863         << getOpenMPDirectiveName(Kind) << VD;
2864     bool IsDecl =
2865         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2866     Diag(VD->getLocation(),
2867          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2868         << VD;
2869     return ExprError();
2870   }
2871   // OpenMP [2.9.2, Restrictions, C/C++, p.6]
2872   //   A threadprivate directive for static block-scope variables must appear
2873   //   in the scope of the variable and not in a nested scope.
2874   if (CanonicalVD->isLocalVarDecl() && CurScope &&
2875       !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
2876     Diag(Id.getLoc(), diag::err_omp_var_scope)
2877         << getOpenMPDirectiveName(Kind) << VD;
2878     bool IsDecl =
2879         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2880     Diag(VD->getLocation(),
2881          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2882         << VD;
2883     return ExprError();
2884   }
2885
2886   // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
2887   //   A threadprivate directive must lexically precede all references to any
2888   //   of the variables in its list.
2889   if (Kind == OMPD_threadprivate && VD->isUsed() &&
2890       !DSAStack->isThreadPrivate(VD)) {
2891     Diag(Id.getLoc(), diag::err_omp_var_used)
2892         << getOpenMPDirectiveName(Kind) << VD;
2893     return ExprError();
2894   }
2895
2896   QualType ExprType = VD->getType().getNonReferenceType();
2897   return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
2898                              SourceLocation(), VD,
2899                              /*RefersToEnclosingVariableOrCapture=*/false,
2900                              Id.getLoc(), ExprType, VK_LValue);
2901 }
2902
2903 Sema::DeclGroupPtrTy
2904 Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
2905                                         ArrayRef<Expr *> VarList) {
2906   if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
2907     CurContext->addDecl(D);
2908     return DeclGroupPtrTy::make(DeclGroupRef(D));
2909   }
2910   return nullptr;
2911 }
2912
2913 namespace {
2914 class LocalVarRefChecker final
2915     : public ConstStmtVisitor<LocalVarRefChecker, bool> {
2916   Sema &SemaRef;
2917
2918 public:
2919   bool VisitDeclRefExpr(const DeclRefExpr *E) {
2920     if (const auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
2921       if (VD->hasLocalStorage()) {
2922         SemaRef.Diag(E->getBeginLoc(),
2923                      diag::err_omp_local_var_in_threadprivate_init)
2924             << E->getSourceRange();
2925         SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
2926             << VD << VD->getSourceRange();
2927         return true;
2928       }
2929     }
2930     return false;
2931   }
2932   bool VisitStmt(const Stmt *S) {
2933     for (const Stmt *Child : S->children()) {
2934       if (Child && Visit(Child))
2935         return true;
2936     }
2937     return false;
2938   }
2939   explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
2940 };
2941 } // namespace
2942
2943 OMPThreadPrivateDecl *
2944 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
2945   SmallVector<Expr *, 8> Vars;
2946   for (Expr *RefExpr : VarList) {
2947     auto *DE = cast<DeclRefExpr>(RefExpr);
2948     auto *VD = cast<VarDecl>(DE->getDecl());
2949     SourceLocation ILoc = DE->getExprLoc();
2950
2951     // Mark variable as used.
2952     VD->setReferenced();
2953     VD->markUsed(Context);
2954
2955     QualType QType = VD->getType();
2956     if (QType->isDependentType() || QType->isInstantiationDependentType()) {
2957       // It will be analyzed later.
2958       Vars.push_back(DE);
2959       continue;
2960     }
2961
2962     // OpenMP [2.9.2, Restrictions, C/C++, p.10]
2963     //   A threadprivate variable must not have an incomplete type.
2964     if (RequireCompleteType(ILoc, VD->getType(),
2965                             diag::err_omp_threadprivate_incomplete_type)) {
2966       continue;
2967     }
2968
2969     // OpenMP [2.9.2, Restrictions, C/C++, p.10]
2970     //   A threadprivate variable must not have a reference type.
2971     if (VD->getType()->isReferenceType()) {
2972       Diag(ILoc, diag::err_omp_ref_type_arg)
2973           << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
2974       bool IsDecl =
2975           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2976       Diag(VD->getLocation(),
2977            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2978           << VD;
2979       continue;
2980     }
2981
2982     // Check if this is a TLS variable. If TLS is not being supported, produce
2983     // the corresponding diagnostic.
2984     if ((VD->getTLSKind() != VarDecl::TLS_None &&
2985          !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
2986            getLangOpts().OpenMPUseTLS &&
2987            getASTContext().getTargetInfo().isTLSSupported())) ||
2988         (VD->getStorageClass() == StorageClass::Register &&
2989          VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
2990       Diag(ILoc, diag::err_omp_var_thread_local)
2991           << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
2992       bool IsDecl =
2993           VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
2994       Diag(VD->getLocation(),
2995            IsDecl ? diag::note_previous_decl : diag::note_defined_here)
2996           << VD;
2997       continue;
2998     }
2999
3000     // Check if initial value of threadprivate variable reference variable with
3001     // local storage (it is not supported by runtime).
3002     if (const Expr *Init = VD->getAnyInitializer()) {
3003       LocalVarRefChecker Checker(*this);
3004       if (Checker.Visit(Init))
3005         continue;
3006     }
3007
3008     Vars.push_back(RefExpr);
3009     DSAStack->addDSA(VD, DE, OMPC_threadprivate);
3010     VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
3011         Context, SourceRange(Loc, Loc)));
3012     if (ASTMutationListener *ML = Context.getASTMutationListener())
3013       ML->DeclarationMarkedOpenMPThreadPrivate(VD);
3014   }
3015   OMPThreadPrivateDecl *D = nullptr;
3016   if (!Vars.empty()) {
3017     D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
3018                                      Vars);
3019     D->setAccess(AS_public);
3020   }
3021   return D;
3022 }
3023
3024 static OMPAllocateDeclAttr::AllocatorTypeTy
3025 getAllocatorKind(Sema &S, DSAStackTy *Stack, Expr *Allocator) {
3026   if (!Allocator)
3027     return OMPAllocateDeclAttr::OMPNullMemAlloc;
3028   if (Allocator->isTypeDependent() || Allocator->isValueDependent() ||
3029       Allocator->isInstantiationDependent() ||
3030       Allocator->containsUnexpandedParameterPack())
3031     return OMPAllocateDeclAttr::OMPUserDefinedMemAlloc;
3032   auto AllocatorKindRes = OMPAllocateDeclAttr::OMPUserDefinedMemAlloc;
3033   const Expr *AE = Allocator->IgnoreParenImpCasts();
3034   for (int I = 0; I < OMPAllocateDeclAttr::OMPUserDefinedMemAlloc; ++I) {
3035     auto AllocatorKind = static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(I);
3036     const Expr *DefAllocator = Stack->getAllocator(AllocatorKind);
3037     llvm::FoldingSetNodeID AEId, DAEId;
3038     AE->Profile(AEId, S.getASTContext(), /*Canonical=*/true);
3039     DefAllocator->Profile(DAEId, S.getASTContext(), /*Canonical=*/true);
3040     if (AEId == DAEId) {
3041       AllocatorKindRes = AllocatorKind;
3042       break;
3043     }
3044   }
3045   return AllocatorKindRes;
3046 }
3047
3048 static bool checkPreviousOMPAllocateAttribute(
3049     Sema &S, DSAStackTy *Stack, Expr *RefExpr, VarDecl *VD,
3050     OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind, Expr *Allocator) {
3051   if (!VD->hasAttr<OMPAllocateDeclAttr>())
3052     return false;
3053   const auto *A = VD->getAttr<OMPAllocateDeclAttr>();
3054   Expr *PrevAllocator = A->getAllocator();
3055   OMPAllocateDeclAttr::AllocatorTypeTy PrevAllocatorKind =
3056       getAllocatorKind(S, Stack, PrevAllocator);
3057   bool AllocatorsMatch = AllocatorKind == PrevAllocatorKind;
3058   if (AllocatorsMatch &&
3059       AllocatorKind == OMPAllocateDeclAttr::OMPUserDefinedMemAlloc &&
3060       Allocator && PrevAllocator) {
3061     const Expr *AE = Allocator->IgnoreParenImpCasts();
3062     const Expr *PAE = PrevAllocator->IgnoreParenImpCasts();
3063     llvm::FoldingSetNodeID AEId, PAEId;
3064     AE->Profile(AEId, S.Context, /*Canonical=*/true);
3065     PAE->Profile(PAEId, S.Context, /*Canonical=*/true);
3066     AllocatorsMatch = AEId == PAEId;
3067   }
3068   if (!AllocatorsMatch) {
3069     SmallString<256> AllocatorBuffer;
3070     llvm::raw_svector_ostream AllocatorStream(AllocatorBuffer);
3071     if (Allocator)
3072       Allocator->printPretty(AllocatorStream, nullptr, S.getPrintingPolicy());
3073     SmallString<256> PrevAllocatorBuffer;
3074     llvm::raw_svector_ostream PrevAllocatorStream(PrevAllocatorBuffer);
3075     if (PrevAllocator)
3076       PrevAllocator->printPretty(PrevAllocatorStream, nullptr,
3077                                  S.getPrintingPolicy());
3078
3079     SourceLocation AllocatorLoc =
3080         Allocator ? Allocator->getExprLoc() : RefExpr->getExprLoc();
3081     SourceRange AllocatorRange =
3082         Allocator ? Allocator->getSourceRange() : RefExpr->getSourceRange();
3083     SourceLocation PrevAllocatorLoc =
3084         PrevAllocator ? PrevAllocator->getExprLoc() : A->getLocation();
3085     SourceRange PrevAllocatorRange =
3086         PrevAllocator ? PrevAllocator->getSourceRange() : A->getRange();
3087     S.Diag(AllocatorLoc, diag::warn_omp_used_different_allocator)
3088         << (Allocator ? 1 : 0) << AllocatorStream.str()
3089         << (PrevAllocator ? 1 : 0) << PrevAllocatorStream.str()
3090         << AllocatorRange;
3091     S.Diag(PrevAllocatorLoc, diag::note_omp_previous_allocator)
3092         << PrevAllocatorRange;
3093     return true;
3094   }
3095   return false;
3096 }
3097
3098 static void
3099 applyOMPAllocateAttribute(Sema &S, VarDecl *VD,
3100                           OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind,
3101                           Expr *Allocator, SourceRange SR) {
3102   if (VD->hasAttr<OMPAllocateDeclAttr>())
3103     return;
3104   if (Allocator &&
3105       (Allocator->isTypeDependent() || Allocator->isValueDependent() ||
3106        Allocator->isInstantiationDependent() ||
3107        Allocator->containsUnexpandedParameterPack()))
3108     return;
3109   auto *A = OMPAllocateDeclAttr::CreateImplicit(S.Context, AllocatorKind,
3110                                                 Allocator, SR);
3111   VD->addAttr(A);
3112   if (ASTMutationListener *ML = S.Context.getASTMutationListener())
3113     ML->DeclarationMarkedOpenMPAllocate(VD, A);
3114 }
3115
3116 Sema::DeclGroupPtrTy Sema::ActOnOpenMPAllocateDirective(
3117     SourceLocation Loc, ArrayRef<Expr *> VarList,
3118     ArrayRef<OMPClause *> Clauses, DeclContext *Owner) {
3119   assert(Clauses.size() <= 1 && "Expected at most one clause.");
3120   Expr *Allocator = nullptr;
3121   if (Clauses.empty()) {
3122     // OpenMP 5.0, 2.11.3 allocate Directive, Restrictions.
3123     // allocate directives that appear in a target region must specify an
3124     // allocator clause unless a requires directive with the dynamic_allocators
3125     // clause is present in the same compilation unit.
3126     if (LangOpts.OpenMPIsDevice &&
3127         !DSAStack->hasRequiresDeclWithClause<OMPDynamicAllocatorsClause>())
3128       targetDiag(Loc, diag::err_expected_allocator_clause);
3129   } else {
3130     Allocator = cast<OMPAllocatorClause>(Clauses.back())->getAllocator();
3131   }
3132   OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind =
3133       getAllocatorKind(*this, DSAStack, Allocator);
3134   SmallVector<Expr *, 8> Vars;
3135   for (Expr *RefExpr : VarList) {
3136     auto *DE = cast<DeclRefExpr>(RefExpr);
3137     auto *VD = cast<VarDecl>(DE->getDecl());
3138
3139     // Check if this is a TLS variable or global register.
3140     if (VD->getTLSKind() != VarDecl::TLS_None ||
3141         VD->hasAttr<OMPThreadPrivateDeclAttr>() ||
3142         (VD->getStorageClass() == StorageClass::Register &&
3143          VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl()))
3144       continue;
3145
3146     // If the used several times in the allocate directive, the same allocator
3147     // must be used.
3148     if (checkPreviousOMPAllocateAttribute(*this, DSAStack, RefExpr, VD,
3149                                           AllocatorKind, Allocator))
3150       continue;
3151
3152     // OpenMP, 2.11.3 allocate Directive, Restrictions, C / C++
3153     // If a list item has a static storage type, the allocator expression in the
3154     // allocator clause must be a constant expression that evaluates to one of
3155     // the predefined memory allocator values.
3156     if (Allocator && VD->hasGlobalStorage()) {
3157       if (AllocatorKind == OMPAllocateDeclAttr::OMPUserDefinedMemAlloc) {
3158         Diag(Allocator->getExprLoc(),
3159              diag::err_omp_expected_predefined_allocator)
3160             << Allocator->getSourceRange();
3161         bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
3162                       VarDecl::DeclarationOnly;
3163         Diag(VD->getLocation(),
3164              IsDecl ? diag::note_previous_decl : diag::note_defined_here)
3165             << VD;
3166         continue;
3167       }
3168     }
3169
3170     Vars.push_back(RefExpr);
3171     applyOMPAllocateAttribute(*this, VD, AllocatorKind, Allocator,
3172                               DE->getSourceRange());
3173   }
3174   if (Vars.empty())
3175     return nullptr;
3176   if (!Owner)
3177     Owner = getCurLexicalContext();
3178   auto *D = OMPAllocateDecl::Create(Context, Owner, Loc, Vars, Clauses);
3179   D->setAccess(AS_public);
3180   Owner->addDecl(D);
3181   return DeclGroupPtrTy::make(DeclGroupRef(D));
3182 }
3183
3184 Sema::DeclGroupPtrTy
3185 Sema::ActOnOpenMPRequiresDirective(SourceLocation Loc,
3186                                    ArrayRef<OMPClause *> ClauseList) {
3187   OMPRequiresDecl *D = nullptr;
3188   if (!CurContext->isFileContext()) {
3189     Diag(Loc, diag::err_omp_invalid_scope) << "requires";
3190   } else {
3191     D = CheckOMPRequiresDecl(Loc, ClauseList);
3192     if (D) {
3193       CurContext->addDecl(D);
3194       DSAStack->addRequiresDecl(D);
3195     }
3196   }
3197   return DeclGroupPtrTy::make(DeclGroupRef(D));
3198 }
3199
3200 void Sema::ActOnOpenMPAssumesDirective(SourceLocation Loc,
3201                                        OpenMPDirectiveKind DKind,
3202                                        ArrayRef<StringRef> Assumptions,
3203                                        bool SkippedClauses) {
3204   if (!SkippedClauses && Assumptions.empty())
3205     Diag(Loc, diag::err_omp_no_clause_for_directive)
3206         << llvm::omp::getAllAssumeClauseOptions()
3207         << llvm::omp::getOpenMPDirectiveName(DKind);
3208
3209   auto *AA = AssumptionAttr::Create(Context, llvm::join(Assumptions, ","), Loc);
3210   if (DKind == llvm::omp::Directive::OMPD_begin_assumes) {
3211     OMPAssumeScoped.push_back(AA);
3212     return;
3213   }
3214
3215   // Global assumes without assumption clauses are ignored.
3216   if (Assumptions.empty())
3217     return;
3218
3219   assert(DKind == llvm::omp::Directive::OMPD_assumes &&
3220          "Unexpected omp assumption directive!");
3221   OMPAssumeGlobal.push_back(AA);
3222
3223   // The OMPAssumeGlobal scope above will take care of new declarations but
3224   // we also want to apply the assumption to existing ones, e.g., to
3225   // declarations in included headers. To this end, we traverse all existing
3226   // declaration contexts and annotate function declarations here.
3227   SmallVector<DeclContext *, 8> DeclContexts;
3228   auto *Ctx = CurContext;
3229   while (Ctx->getLexicalParent())
3230     Ctx = Ctx->getLexicalParent();
3231   DeclContexts.push_back(Ctx);
3232   while (!DeclContexts.empty()) {
3233     DeclContext *DC = DeclContexts.pop_back_val();
3234     for (auto *SubDC : DC->decls()) {
3235       if (SubDC->isInvalidDecl())
3236         continue;
3237       if (auto *CTD = dyn_cast<ClassTemplateDecl>(SubDC)) {
3238         DeclContexts.push_back(CTD->getTemplatedDecl());
3239         for (auto *S : CTD->specializations())
3240           DeclContexts.push_back(S);
3241         continue;
3242       }
3243       if (auto *DC = dyn_cast<DeclContext>(SubDC))
3244         DeclContexts.push_back(DC);
3245       if (auto *F = dyn_cast<FunctionDecl>(SubDC)) {
3246         F->addAttr(AA);
3247         continue;
3248       }
3249     }
3250   }
3251 }
3252
3253 void Sema::ActOnOpenMPEndAssumesDirective() {
3254   assert(isInOpenMPAssumeScope() && "Not in OpenMP assumes scope!");
3255   OMPAssumeScoped.pop_back();
3256 }
3257
3258 OMPRequiresDecl *Sema::CheckOMPRequiresDecl(SourceLocation Loc,
3259                                             ArrayRef<OMPClause *> ClauseList) {
3260   /// For target specific clauses, the requires directive cannot be
3261   /// specified after the handling of any of the target regions in the
3262   /// current compilation unit.
3263   ArrayRef<SourceLocation> TargetLocations =
3264       DSAStack->getEncounteredTargetLocs();
3265   SourceLocation AtomicLoc = DSAStack->getAtomicDirectiveLoc();
3266   if (!TargetLocations.empty() || !AtomicLoc.isInvalid()) {
3267     for (const OMPClause *CNew : ClauseList) {
3268       // Check if any of the requires clauses affect target regions.
3269       if (isa<OMPUnifiedSharedMemoryClause>(CNew) ||
3270           isa<OMPUnifiedAddressClause>(CNew) ||
3271           isa<OMPReverseOffloadClause>(CNew) ||
3272           isa<OMPDynamicAllocatorsClause>(CNew)) {
3273         Diag(Loc, diag::err_omp_directive_before_requires)
3274             << "target" << getOpenMPClauseName(CNew->getClauseKind());
3275         for (SourceLocation TargetLoc : TargetLocations) {
3276           Diag(TargetLoc, diag::note_omp_requires_encountered_directive)
3277               << "target";
3278         }
3279       } else if (!AtomicLoc.isInvalid() &&
3280                  isa<OMPAtomicDefaultMemOrderClause>(CNew)) {
3281         Diag(Loc, diag::err_omp_directive_before_requires)
3282             << "atomic" << getOpenMPClauseName(CNew->getClauseKind());
3283         Diag(AtomicLoc, diag::note_omp_requires_encountered_directive)
3284             << "atomic";
3285       }
3286     }
3287   }
3288
3289   if (!DSAStack->hasDuplicateRequiresClause(ClauseList))
3290     return OMPRequiresDecl::Create(Context, getCurLexicalContext(), Loc,
3291                                    ClauseList);
3292   return nullptr;
3293 }
3294
3295 static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack,
3296                               const ValueDecl *D,
3297                               const DSAStackTy::DSAVarData &DVar,
3298                               bool IsLoopIterVar) {
3299   if (DVar.RefExpr) {
3300     SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
3301         << getOpenMPClauseName(DVar.CKind);
3302     return;
3303   }
3304   enum {
3305     PDSA_StaticMemberShared,
3306     PDSA_StaticLocalVarShared,
3307     PDSA_LoopIterVarPrivate,
3308     PDSA_LoopIterVarLinear,
3309     PDSA_LoopIterVarLastprivate,
3310     PDSA_ConstVarShared,
3311     PDSA_GlobalVarShared,
3312     PDSA_TaskVarFirstprivate,
3313     PDSA_LocalVarPrivate,
3314     PDSA_Implicit
3315   } Reason = PDSA_Implicit;
3316   bool ReportHint = false;
3317   auto ReportLoc = D->getLocation();
3318   auto *VD = dyn_cast<VarDecl>(D);
3319   if (IsLoopIterVar) {
3320     if (DVar.CKind == OMPC_private)
3321       Reason = PDSA_LoopIterVarPrivate;
3322     else if (DVar.CKind == OMPC_lastprivate)
3323       Reason = PDSA_LoopIterVarLastprivate;
3324     else
3325       Reason = PDSA_LoopIterVarLinear;
3326   } else if (isOpenMPTaskingDirective(DVar.DKind) &&
3327              DVar.CKind == OMPC_firstprivate) {
3328     Reason = PDSA_TaskVarFirstprivate;
3329     ReportLoc = DVar.ImplicitDSALoc;
3330   } else if (VD && VD->isStaticLocal())
3331     Reason = PDSA_StaticLocalVarShared;
3332   else if (VD && VD->isStaticDataMember())
3333     Reason = PDSA_StaticMemberShared;
3334   else if (VD && VD->isFileVarDecl())
3335     Reason = PDSA_GlobalVarShared;
3336   else if (D->getType().isConstant(SemaRef.getASTContext()))
3337     Reason = PDSA_ConstVarShared;
3338   else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
3339     ReportHint = true;
3340     Reason = PDSA_LocalVarPrivate;
3341   }
3342   if (Reason != PDSA_Implicit) {
3343     SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
3344         << Reason << ReportHint
3345         << getOpenMPDirectiveName(Stack->getCurrentDirective());
3346   } else if (DVar.ImplicitDSALoc.isValid()) {
3347     SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
3348         << getOpenMPClauseName(DVar.CKind);
3349   }
3350 }
3351
3352 static OpenMPMapClauseKind
3353 getMapClauseKindFromModifier(OpenMPDefaultmapClauseModifier M,
3354                              bool IsAggregateOrDeclareTarget) {
3355   OpenMPMapClauseKind Kind = OMPC_MAP_unknown;
3356   switch (M) {
3357   case OMPC_DEFAULTMAP_MODIFIER_alloc:
3358     Kind = OMPC_MAP_alloc;
3359     break;
3360   case OMPC_DEFAULTMAP_MODIFIER_to:
3361     Kind = OMPC_MAP_to;
3362     break;
3363   case OMPC_DEFAULTMAP_MODIFIER_from:
3364     Kind = OMPC_MAP_from;
3365     break;
3366   case OMPC_DEFAULTMAP_MODIFIER_tofrom:
3367     Kind = OMPC_MAP_tofrom;
3368     break;
3369   case OMPC_DEFAULTMAP_MODIFIER_present:
3370     // OpenMP 5.1 [2.21.7.3] defaultmap clause, Description]
3371     // If implicit-behavior is present, each variable referenced in the
3372     // construct in the category specified by variable-category is treated as if
3373     // it had been listed in a map clause with the map-type of alloc and
3374     // map-type-modifier of present.
3375     Kind = OMPC_MAP_alloc;
3376     break;
3377   case OMPC_DEFAULTMAP_MODIFIER_firstprivate:
3378   case OMPC_DEFAULTMAP_MODIFIER_last:
3379     llvm_unreachable("Unexpected defaultmap implicit behavior");
3380   case OMPC_DEFAULTMAP_MODIFIER_none:
3381   case OMPC_DEFAULTMAP_MODIFIER_default:
3382   case OMPC_DEFAULTMAP_MODIFIER_unknown:
3383     // IsAggregateOrDeclareTarget could be true if:
3384     // 1. the implicit behavior for aggregate is tofrom
3385     // 2. it's a declare target link
3386     if (IsAggregateOrDeclareTarget) {
3387       Kind = OMPC_MAP_tofrom;
3388       break;
3389     }
3390     llvm_unreachable("Unexpected defaultmap implicit behavior");
3391   }
3392   assert(Kind != OMPC_MAP_unknown && "Expect map kind to be known");
3393   return Kind;
3394 }
3395
3396 namespace {
3397 class DSAAttrChecker final : public StmtVisitor<DSAAttrChecker, void> {
3398   DSAStackTy *Stack;
3399   Sema &SemaRef;
3400   bool ErrorFound = false;
3401   bool TryCaptureCXXThisMembers = false;
3402   CapturedStmt *CS = nullptr;
3403   const static unsigned DefaultmapKindNum = OMPC_DEFAULTMAP_pointer + 1;
3404   llvm::SmallVector<Expr *, 4> ImplicitFirstprivate;
3405   llvm::SmallVector<Expr *, 4> ImplicitMap[DefaultmapKindNum][OMPC_MAP_delete];
3406   llvm::SmallVector<OpenMPMapModifierKind, NumberOfOMPMapClauseModifiers>
3407       ImplicitMapModifier[DefaultmapKindNum];
3408   Sema::VarsWithInheritedDSAType VarsWithInheritedDSA;
3409   llvm::SmallDenseSet<const ValueDecl *, 4> ImplicitDeclarations;
3410
3411   void VisitSubCaptures(OMPExecutableDirective *S) {
3412     // Check implicitly captured variables.
3413     if (!S->hasAssociatedStmt() || !S->getAssociatedStmt())
3414       return;
3415     if (S->getDirectiveKind() == OMPD_atomic ||
3416         S->getDirectiveKind() == OMPD_critical ||
3417         S->getDirectiveKind() == OMPD_section ||
3418         S->getDirectiveKind() == OMPD_master) {
3419       Visit(S->getAssociatedStmt());
3420       return;
3421     }
3422     visitSubCaptures(S->getInnermostCapturedStmt());
3423     // Try to capture inner this->member references to generate correct mappings
3424     // and diagnostics.
3425     if (TryCaptureCXXThisMembers ||
3426         (isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()) &&
3427          llvm::any_of(S->getInnermostCapturedStmt()->captures(),
3428                       [](const CapturedStmt::Capture &C) {
3429                         return C.capturesThis();
3430                       }))) {
3431       bool SavedTryCaptureCXXThisMembers = TryCaptureCXXThisMembers;
3432       TryCaptureCXXThisMembers = true;
3433       Visit(S->getInnermostCapturedStmt()->getCapturedStmt());
3434       TryCaptureCXXThisMembers = SavedTryCaptureCXXThisMembers;
3435     }
3436     // In tasks firstprivates are not captured anymore, need to analyze them
3437     // explicitly.
3438     if (isOpenMPTaskingDirective(S->getDirectiveKind()) &&
3439         !isOpenMPTaskLoopDirective(S->getDirectiveKind())) {
3440       for (OMPClause *C : S->clauses())
3441         if (auto *FC = dyn_cast<OMPFirstprivateClause>(C)) {
3442           for (Expr *Ref : FC->varlists())
3443             Visit(Ref);
3444         }
3445     }
3446   }
3447
3448 public:
3449   void VisitDeclRefExpr(DeclRefExpr *E) {
3450     if (TryCaptureCXXThisMembers || E->isTypeDependent() ||
3451         E->isValueDependent() || E->containsUnexpandedParameterPack() ||
3452         E->isInstantiationDependent())
3453       return;
3454     if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
3455       // Check the datasharing rules for the expressions in the clauses.
3456       if (!CS) {
3457         if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
3458           if (!CED->hasAttr<OMPCaptureNoInitAttr>()) {
3459             Visit(CED->getInit());
3460             return;
3461           }
3462       } else if (VD->isImplicit() || isa<OMPCapturedExprDecl>(VD))
3463         // Do not analyze internal variables and do not enclose them into
3464         // implicit clauses.
3465         return;
3466       VD = VD->getCanonicalDecl();
3467       // Skip internally declared variables.
3468       if (VD->hasLocalStorage() && CS && !CS->capturesVariable(VD) &&
3469           !Stack->isImplicitTaskFirstprivate(VD))
3470         return;
3471       // Skip allocators in uses_allocators clauses.
3472       if (Stack->isUsesAllocatorsDecl(VD).hasValue())
3473         return;
3474
3475       DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, /*FromParent=*/false);
3476       // Check if the variable has explicit DSA set and stop analysis if it so.
3477       if (DVar.RefExpr || !ImplicitDeclarations.insert(VD).second)
3478         return;
3479
3480       // Skip internally declared static variables.
3481       llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3482           OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);
3483       if (VD->hasGlobalStorage() && CS && !CS->capturesVariable(VD) &&
3484           (Stack->hasRequiresDeclWithClause<OMPUnifiedSharedMemoryClause>() ||
3485            !Res || *Res != OMPDeclareTargetDeclAttr::MT_Link) &&
3486           !Stack->isImplicitTaskFirstprivate(VD))
3487         return;
3488
3489       SourceLocation ELoc = E->getExprLoc();
3490       OpenMPDirectiveKind DKind = Stack->getCurrentDirective();
3491       // The default(none) clause requires that each variable that is referenced
3492       // in the construct, and does not have a predetermined data-sharing
3493       // attribute, must have its data-sharing attribute explicitly determined
3494       // by being listed in a data-sharing attribute clause.
3495       if (DVar.CKind == OMPC_unknown &&
3496           (Stack->getDefaultDSA() == DSA_none ||
3497            Stack->getDefaultDSA() == DSA_firstprivate) &&
3498           isImplicitOrExplicitTaskingRegion(DKind) &&
3499           VarsWithInheritedDSA.count(VD) == 0) {
3500         bool InheritedDSA = Stack->getDefaultDSA() == DSA_none;
3501         if (!InheritedDSA && Stack->getDefaultDSA() == DSA_firstprivate) {
3502           DSAStackTy::DSAVarData DVar =
3503               Stack->getImplicitDSA(VD, /*FromParent=*/false);
3504           InheritedDSA = DVar.CKind == OMPC_unknown;
3505         }
3506         if (InheritedDSA)
3507           VarsWithInheritedDSA[VD] = E;
3508         return;
3509       }
3510
3511       // OpenMP 5.0 [2.19.7.2, defaultmap clause, Description]
3512       // If implicit-behavior is none, each variable referenced in the
3513       // construct that does not have a predetermined data-sharing attribute
3514       // and does not appear in a to or link clause on a declare target
3515       // directive must be listed in a data-mapping attribute clause, a
3516       // data-haring attribute clause (including a data-sharing attribute
3517       // clause on a combined construct where target. is one of the
3518       // constituent constructs), or an is_device_ptr clause.
3519       OpenMPDefaultmapClauseKind ClauseKind =
3520           getVariableCategoryFromDecl(SemaRef.getLangOpts(), VD);
3521       if (SemaRef.getLangOpts().OpenMP >= 50) {
3522         bool IsModifierNone = Stack->getDefaultmapModifier(ClauseKind) ==
3523                               OMPC_DEFAULTMAP_MODIFIER_none;
3524         if (DVar.CKind == OMPC_unknown && IsModifierNone &&
3525             VarsWithInheritedDSA.count(VD) == 0 && !Res) {
3526           // Only check for data-mapping attribute and is_device_ptr here
3527           // since we have already make sure that the declaration does not
3528           // have a data-sharing attribute above
3529           if (!Stack->checkMappableExprComponentListsForDecl(
3530                   VD, /*CurrentRegionOnly=*/true,
3531                   [VD](OMPClauseMappableExprCommon::MappableExprComponentListRef
3532                            MapExprComponents,
3533                        OpenMPClauseKind) {
3534                     auto MI = MapExprComponents.rbegin();
3535                     auto ME = MapExprComponents.rend();
3536                     return MI != ME && MI->getAssociatedDeclaration() == VD;
3537                   })) {
3538             VarsWithInheritedDSA[VD] = E;
3539             return;
3540           }
3541         }
3542       }
3543       if (SemaRef.getLangOpts().OpenMP > 50) {
3544         bool IsModifierPresent = Stack->getDefaultmapModifier(ClauseKind) ==
3545                                  OMPC_DEFAULTMAP_MODIFIER_present;
3546         if (IsModifierPresent) {
3547           if (llvm::find(ImplicitMapModifier[ClauseKind],
3548                          OMPC_MAP_MODIFIER_present) ==
3549               std::end(ImplicitMapModifier[ClauseKind])) {
3550             ImplicitMapModifier[ClauseKind].push_back(
3551                 OMPC_MAP_MODIFIER_present);
3552           }
3553         }
3554       }
3555
3556       if (isOpenMPTargetExecutionDirective(DKind) &&
3557           !Stack->isLoopControlVariable(VD).first) {
3558         if (!Stack->checkMappableExprComponentListsForDecl(
3559                 VD, /*CurrentRegionOnly=*/true,
3560                 [](OMPClauseMappableExprCommon::MappableExprComponentListRef
3561                        StackComponents,
3562                    OpenMPClauseKind) {
3563                   // Variable is used if it has been marked as an array, array
3564                   // section, array shaping or the variable iself.
3565                   return StackComponents.size() == 1 ||
3566                          std::all_of(
3567                              std::next(StackComponents.rbegin()),
3568                              StackComponents.rend(),
3569                              [](const OMPClauseMappableExprCommon::
3570                                     MappableComponent &MC) {
3571                                return MC.getAssociatedDeclaration() ==
3572                                           nullptr &&
3573                                       (isa<OMPArraySectionExpr>(
3574                                            MC.getAssociatedExpression()) ||
3575                                        isa<OMPArrayShapingExpr>(
3576                                            MC.getAssociatedExpression()) ||
3577                                        isa<ArraySubscriptExpr>(
3578                                            MC.getAssociatedExpression()));
3579                              });
3580                 })) {
3581           bool IsFirstprivate = false;
3582           // By default lambdas are captured as firstprivates.
3583           if (const auto *RD =
3584                   VD->getType().getNonReferenceType()->getAsCXXRecordDecl())
3585             IsFirstprivate = RD->isLambda();
3586           IsFirstprivate =
3587               IsFirstprivate || (Stack->mustBeFirstprivate(ClauseKind) && !Res);
3588           if (IsFirstprivate) {
3589             ImplicitFirstprivate.emplace_back(E);
3590           } else {
3591             OpenMPDefaultmapClauseModifier M =
3592                 Stack->getDefaultmapModifier(ClauseKind);
3593             OpenMPMapClauseKind Kind = getMapClauseKindFromModifier(
3594                 M, ClauseKind == OMPC_DEFAULTMAP_aggregate || Res);
3595             ImplicitMap[ClauseKind][Kind].emplace_back(E);
3596           }
3597           return;
3598         }
3599       }
3600
3601       // OpenMP [2.9.3.6, Restrictions, p.2]
3602       //  A list item that appears in a reduction clause of the innermost
3603       //  enclosing worksharing or parallel construct may not be accessed in an
3604       //  explicit task.
3605       DVar = Stack->hasInnermostDSA(
3606           VD,
3607           [](OpenMPClauseKind C, bool AppliedToPointee) {
3608             return C == OMPC_reduction && !AppliedToPointee;
3609           },
3610           [](OpenMPDirectiveKind K) {
3611             return isOpenMPParallelDirective(K) ||
3612                    isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
3613           },
3614           /*FromParent=*/true);
3615       if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
3616         ErrorFound = true;
3617         SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
3618         reportOriginalDsa(SemaRef, Stack, VD, DVar);
3619         return;
3620       }
3621
3622       // Define implicit data-sharing attributes for task.
3623       DVar = Stack->getImplicitDSA(VD, /*FromParent=*/false);
3624       if (((isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared) ||
3625            (Stack->getDefaultDSA() == DSA_firstprivate &&
3626             DVar.CKind == OMPC_firstprivate && !DVar.RefExpr)) &&
3627           !Stack->isLoopControlVariable(VD).first) {
3628         ImplicitFirstprivate.push_back(E);
3629         return;
3630       }
3631
3632       // Store implicitly used globals with declare target link for parent
3633       // target.
3634       if (!isOpenMPTargetExecutionDirective(DKind) && Res &&
3635           *Res == OMPDeclareTargetDeclAttr::MT_Link) {
3636         Stack->addToParentTargetRegionLinkGlobals(E);
3637         return;
3638       }
3639     }
3640   }
3641   void VisitMemberExpr(MemberExpr *E) {
3642     if (E->isTypeDependent() || E->isValueDependent() ||
3643         E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
3644       return;
3645     auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
3646     OpenMPDirectiveKind DKind = Stack->getCurrentDirective();
3647     if (auto *TE = dyn_cast<CXXThisExpr>(E->getBase()->IgnoreParenCasts())) {
3648       if (!FD)
3649         return;
3650       DSAStackTy::DSAVarData DVar = Stack->getTopDSA(FD, /*FromParent=*/false);
3651       // Check if the variable has explicit DSA set and stop analysis if it
3652       // so.
3653       if (DVar.RefExpr || !ImplicitDeclarations.insert(FD).second)
3654         return;
3655
3656       if (isOpenMPTargetExecutionDirective(DKind) &&
3657           !Stack->isLoopControlVariable(FD).first &&
3658           !Stack->checkMappableExprComponentListsForDecl(
3659               FD, /*CurrentRegionOnly=*/true,
3660               [](OMPClauseMappableExprCommon::MappableExprComponentListRef
3661                      StackComponents,
3662                  OpenMPClauseKind) {
3663                 return isa<CXXThisExpr>(
3664                     cast<MemberExpr>(
3665                         StackComponents.back().getAssociatedExpression())
3666                         ->getBase()
3667                         ->IgnoreParens());
3668               })) {
3669         // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3]
3670         //  A bit-field cannot appear in a map clause.
3671         //
3672         if (FD->isBitField())
3673           return;
3674
3675         // Check to see if the member expression is referencing a class that
3676         // has already been explicitly mapped
3677         if (Stack->isClassPreviouslyMapped(TE->getType()))
3678           return;
3679
3680         OpenMPDefaultmapClauseModifier Modifier =
3681             Stack->getDefaultmapModifier(OMPC_DEFAULTMAP_aggregate);
3682         OpenMPDefaultmapClauseKind ClauseKind =
3683             getVariableCategoryFromDecl(SemaRef.getLangOpts(), FD);
3684         OpenMPMapClauseKind Kind = getMapClauseKindFromModifier(
3685             Modifier, /*IsAggregateOrDeclareTarget*/ true);
3686         ImplicitMap[ClauseKind][Kind].emplace_back(E);
3687         return;
3688       }
3689
3690       SourceLocation ELoc = E->getExprLoc();
3691       // OpenMP [2.9.3.6, Restrictions, p.2]
3692       //  A list item that appears in a reduction clause of the innermost
3693       //  enclosing worksharing or parallel construct may not be accessed in
3694       //  an  explicit task.
3695       DVar = Stack->hasInnermostDSA(
3696           FD,
3697           [](OpenMPClauseKind C, bool AppliedToPointee) {
3698             return C == OMPC_reduction && !AppliedToPointee;
3699           },
3700           [](OpenMPDirectiveKind K) {
3701             return isOpenMPParallelDirective(K) ||
3702                    isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
3703           },
3704           /*FromParent=*/true);
3705       if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
3706         ErrorFound = true;
3707         SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
3708         reportOriginalDsa(SemaRef, Stack, FD, DVar);
3709         return;
3710       }
3711
3712       // Define implicit data-sharing attributes for task.
3713       DVar = Stack->getImplicitDSA(FD, /*FromParent=*/false);
3714       if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
3715           !Stack->isLoopControlVariable(FD).first) {
3716         // Check if there is a captured expression for the current field in the
3717         // region. Do not mark it as firstprivate unless there is no captured
3718         // expression.
3719         // TODO: try to make it firstprivate.
3720         if (DVar.CKind != OMPC_unknown)
3721           ImplicitFirstprivate.push_back(E);
3722       }
3723       return;
3724     }
3725     if (isOpenMPTargetExecutionDirective(DKind)) {
3726       OMPClauseMappableExprCommon::MappableExprComponentList CurComponents;
3727       if (!checkMapClauseExpressionBase(SemaRef, E, CurComponents, OMPC_map,
3728                                         Stack->getCurrentDirective(),
3729                                         /*NoDiagnose=*/true))
3730         return;
3731       const auto *VD = cast<ValueDecl>(
3732           CurComponents.back().getAssociatedDeclaration()->getCanonicalDecl());
3733       if (!Stack->checkMappableExprComponentListsForDecl(
3734               VD, /*CurrentRegionOnly=*/true,
3735               [&CurComponents](
3736                   OMPClauseMappableExprCommon::MappableExprComponentListRef
3737                       StackComponents,
3738                   OpenMPClauseKind) {
3739                 auto CCI = CurComponents.rbegin();
3740                 auto CCE = CurComponents.rend();
3741                 for (const auto &SC : llvm::reverse(StackComponents)) {
3742                   // Do both expressions have the same kind?
3743                   if (CCI->getAssociatedExpression()->getStmtClass() !=
3744                       SC.getAssociatedExpression()->getStmtClass())
3745                     if (!((isa<OMPArraySectionExpr>(
3746                                SC.getAssociatedExpression()) ||
3747                            isa<OMPArrayShapingExpr>(
3748                                SC.getAssociatedExpression())) &&
3749                           isa<ArraySubscriptExpr>(
3750                               CCI->getAssociatedExpression())))
3751                       return false;
3752
3753                   const Decl *CCD = CCI->getAssociatedDeclaration();
3754                   const Decl *SCD = SC.getAssociatedDeclaration();
3755                   CCD = CCD ? CCD->getCanonicalDecl() : nullptr;
3756                   SCD = SCD ? SCD->getCanonicalDecl() : nullptr;
3757                   if (SCD != CCD)
3758                     return false;
3759                   std::advance(CCI, 1);
3760                   if (CCI == CCE)
3761                     break;
3762                 }
3763                 return true;
3764               })) {
3765         Visit(E->getBase());
3766       }
3767     } else if (!TryCaptureCXXThisMembers) {
3768       Visit(E->getBase());
3769     }
3770   }
3771   void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
3772     for (OMPClause *C : S->clauses()) {
3773       // Skip analysis of arguments of implicitly defined firstprivate clause
3774       // for task|target directives.
3775       // Skip analysis of arguments of implicitly defined map clause for target
3776       // directives.
3777       if (C && !((isa<OMPFirstprivateClause>(C) || isa<OMPMapClause>(C)) &&
3778                  C->isImplicit() &&
3779                  !isOpenMPTaskingDirective(Stack->getCurrentDirective()))) {
3780         for (Stmt *CC : C->children()) {
3781           if (CC)
3782             Visit(CC);
3783         }
3784       }
3785     }
3786     // Check implicitly captured variables.
3787     VisitSubCaptures(S);
3788   }
3789   void VisitStmt(Stmt *S) {
3790     for (Stmt *C : S->children()) {
3791       if (C) {
3792         // Check implicitly captured variables in the task-based directives to
3793         // check if they must be firstprivatized.
3794         Visit(C);
3795       }
3796     }
3797   }
3798
3799   void visitSubCaptures(CapturedStmt *S) {
3800     for (const CapturedStmt::Capture &Cap : S->captures()) {
3801       if (!Cap.capturesVariable() && !Cap.capturesVariableByCopy())
3802         continue;
3803       VarDecl *VD = Cap.getCapturedVar();
3804       // Do not try to map the variable if it or its sub-component was mapped
3805       // already.
3806       if (isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()) &&
3807           Stack->checkMappableExprComponentListsForDecl(
3808               VD, /*CurrentRegionOnly=*/true,
3809               [](OMPClauseMappableExprCommon::MappableExprComponentListRef,
3810                  OpenMPClauseKind) { return true; }))
3811         continue;
3812       DeclRefExpr *DRE = buildDeclRefExpr(
3813           SemaRef, VD, VD->getType().getNonLValueExprType(SemaRef.Context),
3814           Cap.getLocation(), /*RefersToCapture=*/true);
3815       Visit(DRE);
3816     }
3817   }
3818   bool isErrorFound() const { return ErrorFound; }
3819   ArrayRef<Expr *> getImplicitFirstprivate() const {
3820     return ImplicitFirstprivate;
3821   }
3822   ArrayRef<Expr *> getImplicitMap(OpenMPDefaultmapClauseKind DK,
3823                                   OpenMPMapClauseKind MK) const {
3824     return ImplicitMap[DK][MK];
3825   }
3826   ArrayRef<OpenMPMapModifierKind>
3827   getImplicitMapModifier(OpenMPDefaultmapClauseKind Kind) const {
3828     return ImplicitMapModifier[Kind];
3829   }
3830   const Sema::VarsWithInheritedDSAType &getVarsWithInheritedDSA() const {
3831     return VarsWithInheritedDSA;
3832   }
3833
3834   DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
3835       : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {
3836     // Process declare target link variables for the target directives.
3837     if (isOpenMPTargetExecutionDirective(S->getCurrentDirective())) {
3838       for (DeclRefExpr *E : Stack->getLinkGlobals())
3839         Visit(E);
3840     }
3841   }
3842 };
3843 } // namespace
3844
3845 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
3846   switch (DKind) {
3847   case OMPD_parallel:
3848   case OMPD_parallel_for:
3849   case OMPD_parallel_for_simd:
3850   case OMPD_parallel_sections:
3851   case OMPD_parallel_master:
3852   case OMPD_teams:
3853   case OMPD_teams_distribute:
3854   case OMPD_teams_distribute_simd: {
3855     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
3856     QualType KmpInt32PtrTy =
3857         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
3858     Sema::CapturedParamNameType Params[] = {
3859         std::make_pair(".global_tid.", KmpInt32PtrTy),
3860         std::make_pair(".bound_tid.", KmpInt32PtrTy),
3861         std::make_pair(StringRef(), QualType()) // __context with shared vars
3862     };
3863     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3864                              Params);
3865     break;
3866   }
3867   case OMPD_target_teams:
3868   case OMPD_target_parallel:
3869   case OMPD_target_parallel_for:
3870   case OMPD_target_parallel_for_simd:
3871   case OMPD_target_teams_distribute:
3872   case OMPD_target_teams_distribute_simd: {
3873     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
3874     QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
3875     QualType KmpInt32PtrTy =
3876         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
3877     QualType Args[] = {VoidPtrTy};
3878     FunctionProtoType::ExtProtoInfo EPI;
3879     EPI.Variadic = true;
3880     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
3881     Sema::CapturedParamNameType Params[] = {
3882         std::make_pair(".global_tid.", KmpInt32Ty),
3883         std::make_pair(".part_id.", KmpInt32PtrTy),
3884         std::make_pair(".privates.", VoidPtrTy),
3885         std::make_pair(
3886             ".copy_fn.",
3887             Context.getPointerType(CopyFnType).withConst().withRestrict()),
3888         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
3889         std::make_pair(StringRef(), QualType()) // __context with shared vars
3890     };
3891     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3892                              Params, /*OpenMPCaptureLevel=*/0);
3893     // Mark this captured region as inlined, because we don't use outlined
3894     // function directly.
3895     getCurCapturedRegion()->TheCapturedDecl->addAttr(
3896         AlwaysInlineAttr::CreateImplicit(
3897             Context, {}, AttributeCommonInfo::AS_Keyword,
3898             AlwaysInlineAttr::Keyword_forceinline));
3899     Sema::CapturedParamNameType ParamsTarget[] = {
3900         std::make_pair(StringRef(), QualType()) // __context with shared vars
3901     };
3902     // Start a captured region for 'target' with no implicit parameters.
3903     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3904                              ParamsTarget, /*OpenMPCaptureLevel=*/1);
3905     Sema::CapturedParamNameType ParamsTeamsOrParallel[] = {
3906         std::make_pair(".global_tid.", KmpInt32PtrTy),
3907         std::make_pair(".bound_tid.", KmpInt32PtrTy),
3908         std::make_pair(StringRef(), QualType()) // __context with shared vars
3909     };
3910     // Start a captured region for 'teams' or 'parallel'.  Both regions have
3911     // the same implicit parameters.
3912     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3913                              ParamsTeamsOrParallel, /*OpenMPCaptureLevel=*/2);
3914     break;
3915   }
3916   case OMPD_target:
3917   case OMPD_target_simd: {
3918     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
3919     QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
3920     QualType KmpInt32PtrTy =
3921         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
3922     QualType Args[] = {VoidPtrTy};
3923     FunctionProtoType::ExtProtoInfo EPI;
3924     EPI.Variadic = true;
3925     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
3926     Sema::CapturedParamNameType Params[] = {
3927         std::make_pair(".global_tid.", KmpInt32Ty),
3928         std::make_pair(".part_id.", KmpInt32PtrTy),
3929         std::make_pair(".privates.", VoidPtrTy),
3930         std::make_pair(
3931             ".copy_fn.",
3932             Context.getPointerType(CopyFnType).withConst().withRestrict()),
3933         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
3934         std::make_pair(StringRef(), QualType()) // __context with shared vars
3935     };
3936     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3937                              Params, /*OpenMPCaptureLevel=*/0);
3938     // Mark this captured region as inlined, because we don't use outlined
3939     // function directly.
3940     getCurCapturedRegion()->TheCapturedDecl->addAttr(
3941         AlwaysInlineAttr::CreateImplicit(
3942             Context, {}, AttributeCommonInfo::AS_Keyword,
3943             AlwaysInlineAttr::Keyword_forceinline));
3944     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3945                              std::make_pair(StringRef(), QualType()),
3946                              /*OpenMPCaptureLevel=*/1);
3947     break;
3948   }
3949   case OMPD_atomic:
3950   case OMPD_critical:
3951   case OMPD_section:
3952   case OMPD_master:
3953     break;
3954   case OMPD_simd:
3955   case OMPD_for:
3956   case OMPD_for_simd:
3957   case OMPD_sections:
3958   case OMPD_single:
3959   case OMPD_taskgroup:
3960   case OMPD_distribute:
3961   case OMPD_distribute_simd:
3962   case OMPD_ordered:
3963   case OMPD_target_data: {
3964     Sema::CapturedParamNameType Params[] = {
3965         std::make_pair(StringRef(), QualType()) // __context with shared vars
3966     };
3967     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3968                              Params);
3969     break;
3970   }
3971   case OMPD_task: {
3972     QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
3973     QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
3974     QualType KmpInt32PtrTy =
3975         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
3976     QualType Args[] = {VoidPtrTy};
3977     FunctionProtoType::ExtProtoInfo EPI;
3978     EPI.Variadic = true;
3979     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
3980     Sema::CapturedParamNameType Params[] = {
3981         std::make_pair(".global_tid.", KmpInt32Ty),
3982         std::make_pair(".part_id.", KmpInt32PtrTy),
3983         std::make_pair(".privates.", VoidPtrTy),
3984         std::make_pair(
3985             ".copy_fn.",
3986             Context.getPointerType(CopyFnType).withConst().withRestrict()),
3987         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
3988         std::make_pair(StringRef(), QualType()) // __context with shared vars
3989     };
3990     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
3991                              Params);
3992     // Mark this captured region as inlined, because we don't use outlined
3993     // function directly.
3994     getCurCapturedRegion()->TheCapturedDecl->addAttr(
3995         AlwaysInlineAttr::CreateImplicit(
3996             Context, {}, AttributeCommonInfo::AS_Keyword,
3997             AlwaysInlineAttr::Keyword_forceinline));
3998     break;
3999   }
4000   case OMPD_taskloop:
4001   case OMPD_taskloop_simd:
4002   case OMPD_master_taskloop:
4003   case OMPD_master_taskloop_simd: {
4004     QualType KmpInt32Ty =
4005         Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1)
4006             .withConst();
4007     QualType KmpUInt64Ty =
4008         Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0)
4009             .withConst();
4010     QualType KmpInt64Ty =
4011         Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1)
4012             .withConst();
4013     QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
4014     QualType KmpInt32PtrTy =
4015         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
4016     QualType Args[] = {VoidPtrTy};
4017     FunctionProtoType::ExtProtoInfo EPI;
4018     EPI.Variadic = true;
4019     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
4020     Sema::CapturedParamNameType Params[] = {
4021         std::make_pair(".global_tid.", KmpInt32Ty),
4022         std::make_pair(".part_id.", KmpInt32PtrTy),
4023         std::make_pair(".privates.", VoidPtrTy),
4024         std::make_pair(
4025             ".copy_fn.",
4026             Context.getPointerType(CopyFnType).withConst().withRestrict()),
4027         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
4028         std::make_pair(".lb.", KmpUInt64Ty),
4029         std::make_pair(".ub.", KmpUInt64Ty),
4030         std::make_pair(".st.", KmpInt64Ty),
4031         std::make_pair(".liter.", KmpInt32Ty),
4032         std::make_pair(".reductions.", VoidPtrTy),
4033         std::make_pair(StringRef(), QualType()) // __context with shared vars
4034     };
4035     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
4036                              Params);
4037     // Mark this captured region as inlined, because we don't use outlined
4038     // function directly.
4039     getCurCapturedRegion()->TheCapturedDecl->addAttr(
4040         AlwaysInlineAttr::CreateImplicit(
4041             Context, {}, AttributeCommonInfo::AS_Keyword,
4042             AlwaysInlineAttr::Keyword_forceinline));
4043     break;
4044   }
4045   case OMPD_parallel_master_taskloop:
4046   case OMPD_parallel_master_taskloop_simd: {
4047     QualType KmpInt32Ty =
4048         Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1)
4049             .withConst();
4050     QualType KmpUInt64Ty =
4051         Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0)
4052             .withConst();
4053     QualType KmpInt64Ty =
4054         Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1)
4055             .withConst();
4056     QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
4057     QualType KmpInt32PtrTy =
4058         Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
4059     Sema::CapturedParamNameType ParamsParallel[] = {
4060         std::make_pair(".global_tid.", KmpInt32PtrTy),
4061         std::make_pair(".bound_tid.", KmpInt32PtrTy),
4062         std::make_pair(StringRef(), QualType()) // __context with shared vars
4063     };
4064     // Start a captured region for 'parallel'.
4065     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
4066                              ParamsParallel, /*OpenMPCaptureLevel=*/0);
4067     QualType Args[] = {VoidPtrTy};
4068     FunctionProtoType::ExtProtoInfo EPI;
4069     EPI.Variadic = true;
4070     QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
4071     Sema::CapturedParamNameType Params[] = {
4072         std::make_pair(".global_tid.", KmpInt32Ty),
4073         std::make_pair(".part_id.", KmpInt32PtrTy),
4074         std::make_pair(".privates.", VoidPtrTy),
4075         std::make_pair(
4076             ".copy_fn.",
4077             Context.getPointerType(CopyFnType).withConst().withRestrict()),
4078         std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
4079         std::make_pair(".lb.", KmpUInt64Ty),
4080         std::make_pair(".ub.", KmpUInt64Ty),
4081         std::make_pair(".st.", KmpInt64Ty),
4082         std::make_pair(".liter.", KmpInt32Ty),
4083         std::make_pair(".reductions.", VoidPtrTy),
4084         std::make_pair(StringRef(), QualType()) // __context with shared vars
4085     };
4086     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
4087                              Params, /*OpenMPCaptureLevel=*/1);
4088     // Mark this captured region as inlined, because we don't use outlined
4089     // function directly.
4090     getCurCapturedRegion()->TheCapturedDecl->addAttr(
4091         AlwaysInlineAttr::CreateImplicit(
4092             Context, {}, AttributeCommonInfo::AS_Keyword,
4093             AlwaysInlineAttr::Keyword_forceinline));
4094     break;
4095   }
4096   case OMPD_distribute_parallel_for_simd:
4097   case OMPD_distribute_parallel_for: {
4098