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