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