1 //===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 /// \brief This file implements semantic analysis for OpenMP directives and
13 //===----------------------------------------------------------------------===//
15 #include "TreeTransform.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTMutationListener.h"
18 #include "clang/AST/CXXInheritance.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclOpenMP.h"
22 #include "clang/AST/StmtCXX.h"
23 #include "clang/AST/StmtOpenMP.h"
24 #include "clang/AST/StmtVisitor.h"
25 #include "clang/AST/TypeOrdering.h"
26 #include "clang/Basic/OpenMPKinds.h"
27 #include "clang/Basic/TargetInfo.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Sema/Initialization.h"
30 #include "clang/Sema/Lookup.h"
31 #include "clang/Sema/Scope.h"
32 #include "clang/Sema/ScopeInfo.h"
33 #include "clang/Sema/SemaInternal.h"
34 using namespace clang;
36 //===----------------------------------------------------------------------===//
37 // Stack of data-sharing attributes for variables
38 //===----------------------------------------------------------------------===//
41 /// \brief Default data sharing attributes, which can be applied to directive.
42 enum DefaultDataSharingAttributes {
43 DSA_unspecified = 0, /// \brief Data sharing attribute not specified.
44 DSA_none = 1 << 0, /// \brief Default data sharing attribute 'none'.
45 DSA_shared = 1 << 1 /// \brief Default data sharing attribute 'shared'.
48 /// \brief Stack for tracking declarations used in OpenMP directives and
49 /// clauses and their data-sharing attributes.
50 class DSAStackTy final {
52 struct DSAVarData final {
53 OpenMPDirectiveKind DKind = OMPD_unknown;
54 OpenMPClauseKind CKind = OMPC_unknown;
55 Expr *RefExpr = nullptr;
56 DeclRefExpr *PrivateCopy = nullptr;
57 SourceLocation ImplicitDSALoc;
60 typedef llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4>
64 struct DSAInfo final {
65 OpenMPClauseKind Attributes = OMPC_unknown;
66 /// Pointer to a reference expression and a flag which shows that the
67 /// variable is marked as lastprivate(true) or not (false).
68 llvm::PointerIntPair<Expr *, 1, bool> RefExpr;
69 DeclRefExpr *PrivateCopy = nullptr;
71 typedef llvm::DenseMap<ValueDecl *, DSAInfo> DeclSAMapTy;
72 typedef llvm::DenseMap<ValueDecl *, Expr *> AlignedMapTy;
73 typedef std::pair<unsigned, VarDecl *> LCDeclInfo;
74 typedef llvm::DenseMap<ValueDecl *, LCDeclInfo> LoopControlVariablesMapTy;
75 typedef llvm::DenseMap<
76 ValueDecl *, OMPClauseMappableExprCommon::MappableExprComponentLists>
77 MappedExprComponentsTy;
78 typedef llvm::StringMap<std::pair<OMPCriticalDirective *, llvm::APSInt>>
80 typedef llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>
83 struct SharingMapTy final {
84 DeclSAMapTy SharingMap;
85 AlignedMapTy AlignedMap;
86 MappedExprComponentsTy MappedExprComponents;
87 LoopControlVariablesMapTy LCVMap;
88 DefaultDataSharingAttributes DefaultAttr = DSA_unspecified;
89 SourceLocation DefaultAttrLoc;
90 OpenMPDirectiveKind Directive = OMPD_unknown;
91 DeclarationNameInfo DirectiveName;
92 Scope *CurScope = nullptr;
93 SourceLocation ConstructLoc;
94 /// Set of 'depend' clauses with 'sink|source' dependence kind. Required to
95 /// get the data (loop counters etc.) about enclosing loop-based construct.
96 /// This data is required during codegen.
97 DoacrossDependMapTy DoacrossDepends;
98 /// \brief first argument (Expr *) contains optional argument of the
99 /// 'ordered' clause, the second one is true if the regions has 'ordered'
100 /// clause, false otherwise.
101 llvm::PointerIntPair<Expr *, 1, bool> OrderedRegion;
102 bool NowaitRegion = false;
103 bool CancelRegion = false;
104 unsigned AssociatedLoops = 1;
105 SourceLocation InnerTeamsRegionLoc;
106 SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name,
107 Scope *CurScope, SourceLocation Loc)
108 : Directive(DKind), DirectiveName(Name), CurScope(CurScope),
113 typedef SmallVector<SharingMapTy, 4> StackTy;
115 /// \brief Stack of used declaration and their data-sharing attributes.
117 /// \brief true, if check for DSA must be from parent directive, false, if
118 /// from current directive.
119 OpenMPClauseKind ClauseKindMode = OMPC_unknown;
121 bool ForceCapturing = false;
122 CriticalsWithHintsTy Criticals;
124 typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator;
126 DSAVarData getDSA(StackTy::reverse_iterator& Iter, ValueDecl *D);
128 /// \brief Checks if the variable is a local for OpenMP region.
129 bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter);
132 explicit DSAStackTy(Sema &S) : Stack(1), SemaRef(S) {}
134 bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
135 void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }
137 bool isForceVarCapturing() const { return ForceCapturing; }
138 void setForceVarCapturing(bool V) { ForceCapturing = V; }
140 void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
141 Scope *CurScope, SourceLocation Loc) {
142 Stack.push_back(SharingMapTy(DKind, DirName, CurScope, Loc));
143 Stack.back().DefaultAttrLoc = Loc;
147 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!");
151 void addCriticalWithHint(OMPCriticalDirective *D, llvm::APSInt Hint) {
152 Criticals[D->getDirectiveName().getAsString()] = std::make_pair(D, Hint);
154 const std::pair<OMPCriticalDirective *, llvm::APSInt>
155 getCriticalWithHint(const DeclarationNameInfo &Name) const {
156 auto I = Criticals.find(Name.getAsString());
157 if (I != Criticals.end())
159 return std::make_pair(nullptr, llvm::APSInt());
161 /// \brief If 'aligned' declaration for given variable \a D was not seen yet,
162 /// add it and return NULL; otherwise return previous occurrence's expression
164 Expr *addUniqueAligned(ValueDecl *D, Expr *NewDE);
166 /// \brief Register specified variable as loop control variable.
167 void addLoopControlVariable(ValueDecl *D, VarDecl *Capture);
168 /// \brief Check if the specified variable is a loop control variable for
170 /// \return The index of the loop control variable in the list of associated
171 /// for-loops (from outer to inner).
172 LCDeclInfo isLoopControlVariable(ValueDecl *D);
173 /// \brief Check if the specified variable is a loop control variable for
175 /// \return The index of the loop control variable in the list of associated
176 /// for-loops (from outer to inner).
177 LCDeclInfo isParentLoopControlVariable(ValueDecl *D);
178 /// \brief Get the loop control variable for the I-th loop (or nullptr) in
179 /// parent directive.
180 ValueDecl *getParentLoopControlVariable(unsigned I);
182 /// \brief Adds explicit data sharing attribute to the specified declaration.
183 void addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
184 DeclRefExpr *PrivateCopy = nullptr);
186 /// \brief Returns data sharing attributes from top of the stack for the
187 /// specified declaration.
188 DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
189 /// \brief Returns data-sharing attributes for the specified declaration.
190 DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent);
191 /// \brief Checks if the specified variables has data-sharing attributes which
192 /// match specified \a CPred predicate in any directive which matches \a DPred
194 DSAVarData hasDSA(ValueDecl *D,
195 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
196 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
198 /// \brief Checks if the specified variables has data-sharing attributes which
199 /// match specified \a CPred predicate in any innermost directive which
200 /// matches \a DPred predicate.
202 hasInnermostDSA(ValueDecl *D,
203 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
204 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
206 /// \brief Checks if the specified variables has explicit data-sharing
207 /// attributes which match specified \a CPred predicate at the specified
209 bool hasExplicitDSA(ValueDecl *D,
210 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
211 unsigned Level, bool NotLastprivate = false);
213 /// \brief Returns true if the directive at level \Level matches in the
214 /// specified \a DPred predicate.
215 bool hasExplicitDirective(
216 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
219 /// \brief Finds a directive which matches specified \a DPred predicate.
220 bool hasDirective(const llvm::function_ref<bool(OpenMPDirectiveKind,
221 const DeclarationNameInfo &,
222 SourceLocation)> &DPred,
225 /// \brief Returns currently analyzed directive.
226 OpenMPDirectiveKind getCurrentDirective() const {
227 return Stack.back().Directive;
229 /// \brief Returns parent directive.
230 OpenMPDirectiveKind getParentDirective() const {
231 if (Stack.size() > 2)
232 return Stack[Stack.size() - 2].Directive;
236 /// \brief Set default data sharing attribute to none.
237 void setDefaultDSANone(SourceLocation Loc) {
238 Stack.back().DefaultAttr = DSA_none;
239 Stack.back().DefaultAttrLoc = Loc;
241 /// \brief Set default data sharing attribute to shared.
242 void setDefaultDSAShared(SourceLocation Loc) {
243 Stack.back().DefaultAttr = DSA_shared;
244 Stack.back().DefaultAttrLoc = Loc;
247 DefaultDataSharingAttributes getDefaultDSA() const {
248 return Stack.back().DefaultAttr;
250 SourceLocation getDefaultDSALocation() const {
251 return Stack.back().DefaultAttrLoc;
254 /// \brief Checks if the specified variable is a threadprivate.
255 bool isThreadPrivate(VarDecl *D) {
256 DSAVarData DVar = getTopDSA(D, false);
257 return isOpenMPThreadPrivate(DVar.CKind);
260 /// \brief Marks current region as ordered (it has an 'ordered' clause).
261 void setOrderedRegion(bool IsOrdered, Expr *Param) {
262 Stack.back().OrderedRegion.setInt(IsOrdered);
263 Stack.back().OrderedRegion.setPointer(Param);
265 /// \brief Returns true, if parent region is ordered (has associated
266 /// 'ordered' clause), false - otherwise.
267 bool isParentOrderedRegion() const {
268 if (Stack.size() > 2)
269 return Stack[Stack.size() - 2].OrderedRegion.getInt();
272 /// \brief Returns optional parameter for the ordered region.
273 Expr *getParentOrderedRegionParam() const {
274 if (Stack.size() > 2)
275 return Stack[Stack.size() - 2].OrderedRegion.getPointer();
278 /// \brief Marks current region as nowait (it has a 'nowait' clause).
279 void setNowaitRegion(bool IsNowait = true) {
280 Stack.back().NowaitRegion = IsNowait;
282 /// \brief Returns true, if parent region is nowait (has associated
283 /// 'nowait' clause), false - otherwise.
284 bool isParentNowaitRegion() const {
285 if (Stack.size() > 2)
286 return Stack[Stack.size() - 2].NowaitRegion;
289 /// \brief Marks parent region as cancel region.
290 void setParentCancelRegion(bool Cancel = true) {
291 if (Stack.size() > 2)
292 Stack[Stack.size() - 2].CancelRegion =
293 Stack[Stack.size() - 2].CancelRegion || Cancel;
295 /// \brief Return true if current region has inner cancel construct.
296 bool isCancelRegion() const {
297 return Stack.back().CancelRegion;
300 /// \brief Set collapse value for the region.
301 void setAssociatedLoops(unsigned Val) { Stack.back().AssociatedLoops = Val; }
302 /// \brief Return collapse value for region.
303 unsigned getAssociatedLoops() const { return Stack.back().AssociatedLoops; }
305 /// \brief Marks current target region as one with closely nested teams
307 void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
308 if (Stack.size() > 2)
309 Stack[Stack.size() - 2].InnerTeamsRegionLoc = TeamsRegionLoc;
311 /// \brief Returns true, if current region has closely nested teams region.
312 bool hasInnerTeamsRegion() const {
313 return getInnerTeamsRegionLoc().isValid();
315 /// \brief Returns location of the nested teams region (if any).
316 SourceLocation getInnerTeamsRegionLoc() const {
317 if (Stack.size() > 1)
318 return Stack.back().InnerTeamsRegionLoc;
319 return SourceLocation();
322 Scope *getCurScope() const { return Stack.back().CurScope; }
323 Scope *getCurScope() { return Stack.back().CurScope; }
324 SourceLocation getConstructLoc() { return Stack.back().ConstructLoc; }
326 // Do the check specified in \a Check to all component lists and return true
327 // if any issue is found.
328 bool checkMappableExprComponentListsForDecl(
329 ValueDecl *VD, bool CurrentRegionOnly,
330 const llvm::function_ref<bool(
331 OMPClauseMappableExprCommon::MappableExprComponentListRef)> &Check) {
332 auto SI = Stack.rbegin();
333 auto SE = Stack.rend();
338 if (CurrentRegionOnly) {
344 for (; SI != SE; ++SI) {
345 auto MI = SI->MappedExprComponents.find(VD);
346 if (MI != SI->MappedExprComponents.end())
347 for (auto &L : MI->second)
354 // Create a new mappable expression component list associated with a given
355 // declaration and initialize it with the provided list of components.
356 void addMappableExpressionComponents(
358 OMPClauseMappableExprCommon::MappableExprComponentListRef Components) {
359 assert(Stack.size() > 1 &&
360 "Not expecting to retrieve components from a empty stack!");
361 auto &MEC = Stack.back().MappedExprComponents[VD];
362 // Create new entry and append the new components there.
363 MEC.resize(MEC.size() + 1);
364 MEC.back().append(Components.begin(), Components.end());
367 unsigned getNestingLevel() const {
368 assert(Stack.size() > 1);
369 return Stack.size() - 2;
371 void addDoacrossDependClause(OMPDependClause *C, OperatorOffsetTy &OpsOffs) {
372 assert(Stack.size() > 2);
373 assert(isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive));
374 Stack[Stack.size() - 2].DoacrossDepends.insert({C, OpsOffs});
376 llvm::iterator_range<DoacrossDependMapTy::const_iterator>
377 getDoacrossDependClauses() const {
378 assert(Stack.size() > 1);
379 if (isOpenMPWorksharingDirective(Stack[Stack.size() - 1].Directive)) {
380 auto &Ref = Stack[Stack.size() - 1].DoacrossDepends;
381 return llvm::make_range(Ref.begin(), Ref.end());
383 return llvm::make_range(Stack[0].DoacrossDepends.end(),
384 Stack[0].DoacrossDepends.end());
387 bool isParallelOrTaskRegion(OpenMPDirectiveKind DKind) {
388 return isOpenMPParallelDirective(DKind) || isOpenMPTaskingDirective(DKind) ||
389 isOpenMPTeamsDirective(DKind) || DKind == OMPD_unknown;
393 static ValueDecl *getCanonicalDecl(ValueDecl *D) {
394 auto *VD = dyn_cast<VarDecl>(D);
395 auto *FD = dyn_cast<FieldDecl>(D);
397 VD = VD->getCanonicalDecl();
401 FD = FD->getCanonicalDecl();
407 DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator& Iter,
409 D = getCanonicalDecl(D);
410 auto *VD = dyn_cast<VarDecl>(D);
411 auto *FD = dyn_cast<FieldDecl>(D);
413 if (Iter == std::prev(Stack.rend())) {
414 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
415 // in a region but not in construct]
416 // File-scope or namespace-scope variables referenced in called routines
417 // in the region are shared unless they appear in a threadprivate
419 if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(D))
420 DVar.CKind = OMPC_shared;
422 // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
423 // in a region but not in construct]
424 // Variables with static storage duration that are declared in called
425 // routines in the region are shared.
426 if (VD && VD->hasGlobalStorage())
427 DVar.CKind = OMPC_shared;
429 // Non-static data members are shared by default.
431 DVar.CKind = OMPC_shared;
436 DVar.DKind = Iter->Directive;
437 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
438 // in a Construct, C/C++, predetermined, p.1]
439 // Variables with automatic storage duration that are declared in a scope
440 // inside the construct are private.
441 if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
442 (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
443 DVar.CKind = OMPC_private;
447 // Explicitly specified attributes and local variables with predetermined
449 if (Iter->SharingMap.count(D)) {
450 DVar.RefExpr = Iter->SharingMap[D].RefExpr.getPointer();
451 DVar.PrivateCopy = Iter->SharingMap[D].PrivateCopy;
452 DVar.CKind = Iter->SharingMap[D].Attributes;
453 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
457 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
458 // in a Construct, C/C++, implicitly determined, p.1]
459 // In a parallel or task construct, the data-sharing attributes of these
460 // variables are determined by the default clause, if present.
461 switch (Iter->DefaultAttr) {
463 DVar.CKind = OMPC_shared;
464 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
468 case DSA_unspecified:
469 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
470 // in a Construct, implicitly determined, p.2]
471 // In a parallel construct, if no default clause is present, these
472 // variables are shared.
473 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
474 if (isOpenMPParallelDirective(DVar.DKind) ||
475 isOpenMPTeamsDirective(DVar.DKind)) {
476 DVar.CKind = OMPC_shared;
480 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
481 // in a Construct, implicitly determined, p.4]
482 // In a task construct, if no default clause is present, a variable that in
483 // the enclosing context is determined to be shared by all implicit tasks
484 // bound to the current team is shared.
485 if (isOpenMPTaskingDirective(DVar.DKind)) {
487 for (StackTy::reverse_iterator I = std::next(Iter), EE = Stack.rend();
489 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
490 // Referenced in a Construct, implicitly determined, p.6]
491 // In a task construct, if no default clause is present, a variable
492 // whose data-sharing attribute is not determined by the rules above is
494 DVarTemp = getDSA(I, D);
495 if (DVarTemp.CKind != OMPC_shared) {
496 DVar.RefExpr = nullptr;
497 DVar.CKind = OMPC_firstprivate;
500 if (isParallelOrTaskRegion(I->Directive))
504 (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
508 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
509 // in a Construct, implicitly determined, p.3]
510 // For constructs other than task, if no default clause is present, these
511 // variables inherit their data-sharing attributes from the enclosing
513 return getDSA(++Iter, D);
516 Expr *DSAStackTy::addUniqueAligned(ValueDecl *D, Expr *NewDE) {
517 assert(Stack.size() > 1 && "Data sharing attributes stack is empty");
518 D = getCanonicalDecl(D);
519 auto It = Stack.back().AlignedMap.find(D);
520 if (It == Stack.back().AlignedMap.end()) {
521 assert(NewDE && "Unexpected nullptr expr to be added into aligned map");
522 Stack.back().AlignedMap[D] = NewDE;
525 assert(It->second && "Unexpected nullptr expr in the aligned map");
531 void DSAStackTy::addLoopControlVariable(ValueDecl *D, VarDecl *Capture) {
532 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
533 D = getCanonicalDecl(D);
534 Stack.back().LCVMap.insert(
535 std::make_pair(D, LCDeclInfo(Stack.back().LCVMap.size() + 1, Capture)));
538 DSAStackTy::LCDeclInfo DSAStackTy::isLoopControlVariable(ValueDecl *D) {
539 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
540 D = getCanonicalDecl(D);
541 return Stack.back().LCVMap.count(D) > 0 ? Stack.back().LCVMap[D]
542 : LCDeclInfo(0, nullptr);
545 DSAStackTy::LCDeclInfo DSAStackTy::isParentLoopControlVariable(ValueDecl *D) {
546 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty");
547 D = getCanonicalDecl(D);
548 return Stack[Stack.size() - 2].LCVMap.count(D) > 0
549 ? Stack[Stack.size() - 2].LCVMap[D]
550 : LCDeclInfo(0, nullptr);
553 ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) {
554 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty");
555 if (Stack[Stack.size() - 2].LCVMap.size() < I)
557 for (auto &Pair : Stack[Stack.size() - 2].LCVMap) {
558 if (Pair.second.first == I)
564 void DSAStackTy::addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
565 DeclRefExpr *PrivateCopy) {
566 D = getCanonicalDecl(D);
567 if (A == OMPC_threadprivate) {
568 auto &Data = Stack[0].SharingMap[D];
570 Data.RefExpr.setPointer(E);
571 Data.PrivateCopy = nullptr;
573 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
574 auto &Data = Stack.back().SharingMap[D];
575 assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
576 (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||
577 (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||
578 (isLoopControlVariable(D).first && A == OMPC_private));
579 if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
580 Data.RefExpr.setInt(/*IntVal=*/true);
583 const bool IsLastprivate =
584 A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
586 Data.RefExpr.setPointerAndInt(E, IsLastprivate);
587 Data.PrivateCopy = PrivateCopy;
589 auto &Data = Stack.back().SharingMap[PrivateCopy->getDecl()];
591 Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
592 Data.PrivateCopy = nullptr;
597 bool DSAStackTy::isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter) {
598 D = D->getCanonicalDecl();
599 if (Stack.size() > 2) {
600 reverse_iterator I = Iter, E = std::prev(Stack.rend());
601 Scope *TopScope = nullptr;
602 while (I != E && !isParallelOrTaskRegion(I->Directive)) {
607 TopScope = I->CurScope ? I->CurScope->getParent() : nullptr;
608 Scope *CurScope = getCurScope();
609 while (CurScope != TopScope && !CurScope->isDeclScope(D)) {
610 CurScope = CurScope->getParent();
612 return CurScope != TopScope;
617 /// \brief Build a variable declaration for OpenMP loop iteration variable.
618 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
619 StringRef Name, const AttrVec *Attrs = nullptr) {
620 DeclContext *DC = SemaRef.CurContext;
621 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
622 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
624 VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
626 for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
634 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
636 bool RefersToCapture = false) {
638 D->markUsed(S.Context);
639 return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
640 SourceLocation(), D, RefersToCapture, Loc, Ty,
644 DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D, bool FromParent) {
645 D = getCanonicalDecl(D);
648 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
649 // in a Construct, C/C++, predetermined, p.1]
650 // Variables appearing in threadprivate directives are threadprivate.
651 auto *VD = dyn_cast<VarDecl>(D);
652 if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
653 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
654 SemaRef.getLangOpts().OpenMPUseTLS &&
655 SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
656 (VD && VD->getStorageClass() == SC_Register &&
657 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
658 addDSA(D, buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
662 if (Stack[0].SharingMap.count(D)) {
663 DVar.RefExpr = Stack[0].SharingMap[D].RefExpr.getPointer();
664 DVar.CKind = OMPC_threadprivate;
668 if (Stack.size() == 1) {
669 // Not in OpenMP execution region and top scope was already checked.
673 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
674 // in a Construct, C/C++, predetermined, p.4]
675 // Static data members are shared.
676 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
677 // in a Construct, C/C++, predetermined, p.7]
678 // Variables with static storage duration that are declared in a scope
679 // inside the construct are shared.
680 auto &&MatchesAlways = [](OpenMPDirectiveKind) -> bool { return true; };
681 if (VD && VD->isStaticDataMember()) {
682 DSAVarData DVarTemp = hasDSA(D, isOpenMPPrivate, MatchesAlways, FromParent);
683 if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
686 DVar.CKind = OMPC_shared;
690 QualType Type = D->getType().getNonReferenceType().getCanonicalType();
691 bool IsConstant = Type.isConstant(SemaRef.getASTContext());
692 Type = SemaRef.getASTContext().getBaseElementType(Type);
693 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
694 // in a Construct, C/C++, predetermined, p.6]
695 // Variables with const qualified type having no mutable member are
698 SemaRef.getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr;
699 if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
700 if (auto *CTD = CTSD->getSpecializedTemplate())
701 RD = CTD->getTemplatedDecl();
703 !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() &&
704 RD->hasMutableFields())) {
705 // Variables with const-qualified type having no mutable member may be
706 // listed in a firstprivate clause, even if they are static data members.
707 DSAVarData DVarTemp = hasDSA(
708 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_firstprivate; },
709 MatchesAlways, FromParent);
710 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr)
713 DVar.CKind = OMPC_shared;
717 // Explicitly specified attributes and local variables with predetermined
719 auto StartI = std::next(Stack.rbegin());
720 auto EndI = std::prev(Stack.rend());
721 if (FromParent && StartI != EndI) {
722 StartI = std::next(StartI);
724 auto I = std::prev(StartI);
725 if (I->SharingMap.count(D)) {
726 DVar.RefExpr = I->SharingMap[D].RefExpr.getPointer();
727 DVar.PrivateCopy = I->SharingMap[D].PrivateCopy;
728 DVar.CKind = I->SharingMap[D].Attributes;
729 DVar.ImplicitDSALoc = I->DefaultAttrLoc;
735 DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
737 D = getCanonicalDecl(D);
738 auto StartI = Stack.rbegin();
739 auto EndI = std::prev(Stack.rend());
740 if (FromParent && StartI != EndI) {
741 StartI = std::next(StartI);
743 return getDSA(StartI, D);
746 DSAStackTy::DSAVarData
747 DSAStackTy::hasDSA(ValueDecl *D,
748 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
749 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
751 D = getCanonicalDecl(D);
752 auto StartI = std::next(Stack.rbegin());
753 auto EndI = Stack.rend();
754 if (FromParent && StartI != EndI) {
755 StartI = std::next(StartI);
757 for (auto I = StartI, EE = EndI; I != EE; ++I) {
758 if (!DPred(I->Directive) && !isParallelOrTaskRegion(I->Directive))
760 DSAVarData DVar = getDSA(I, D);
761 if (CPred(DVar.CKind))
767 DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
768 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
769 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
771 D = getCanonicalDecl(D);
772 auto StartI = std::next(Stack.rbegin());
773 auto EndI = Stack.rend();
774 if (FromParent && StartI != EndI) {
775 StartI = std::next(StartI);
777 for (auto I = StartI, EE = EndI; I != EE; ++I) {
778 if (!DPred(I->Directive))
780 DSAVarData DVar = getDSA(I, D);
781 if (CPred(DVar.CKind))
788 bool DSAStackTy::hasExplicitDSA(
789 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
790 unsigned Level, bool NotLastprivate) {
791 if (CPred(ClauseKindMode))
793 D = getCanonicalDecl(D);
794 auto StartI = std::next(Stack.begin());
795 auto EndI = Stack.end();
796 if (std::distance(StartI, EndI) <= (int)Level)
798 std::advance(StartI, Level);
799 return (StartI->SharingMap.count(D) > 0) &&
800 StartI->SharingMap[D].RefExpr.getPointer() &&
801 CPred(StartI->SharingMap[D].Attributes) &&
802 (!NotLastprivate || !StartI->SharingMap[D].RefExpr.getInt());
805 bool DSAStackTy::hasExplicitDirective(
806 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
808 auto StartI = std::next(Stack.begin());
809 auto EndI = Stack.end();
810 if (std::distance(StartI, EndI) <= (int)Level)
812 std::advance(StartI, Level);
813 return DPred(StartI->Directive);
816 bool DSAStackTy::hasDirective(
817 const llvm::function_ref<bool(OpenMPDirectiveKind,
818 const DeclarationNameInfo &, SourceLocation)>
821 // We look only in the enclosing region.
822 if (Stack.size() < 2)
824 auto StartI = std::next(Stack.rbegin());
825 auto EndI = std::prev(Stack.rend());
826 if (FromParent && StartI != EndI) {
827 StartI = std::next(StartI);
829 for (auto I = StartI, EE = EndI; I != EE; ++I) {
830 if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc))
836 void Sema::InitDataSharingAttributesStack() {
837 VarDataSharingAttributesStack = new DSAStackTy(*this);
840 #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack)
842 bool Sema::IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level) {
843 assert(LangOpts.OpenMP && "OpenMP is not allowed");
845 auto &Ctx = getASTContext();
848 // Find the directive that is associated with the provided scope.
849 auto Ty = D->getType();
851 if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) {
852 // This table summarizes how a given variable should be passed to the device
853 // given its type and the clauses where it appears. This table is based on
854 // the description in OpenMP 4.5 [2.10.4, target Construct] and
855 // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses].
857 // =========================================================================
858 // | type | defaultmap | pvt | first | is_device_ptr | map | res. |
859 // | |(tofrom:scalar)| | pvt | | | |
860 // =========================================================================
861 // | scl | | | | - | | bycopy|
862 // | scl | | - | x | - | - | bycopy|
863 // | scl | | x | - | - | - | null |
864 // | scl | x | | | - | | byref |
865 // | scl | x | - | x | - | - | bycopy|
866 // | scl | x | x | - | - | - | null |
867 // | scl | | - | - | - | x | byref |
868 // | scl | x | - | - | - | x | byref |
870 // | agg | n.a. | | | - | | byref |
871 // | agg | n.a. | - | x | - | - | byref |
872 // | agg | n.a. | x | - | - | - | null |
873 // | agg | n.a. | - | - | - | x | byref |
874 // | agg | n.a. | - | - | - | x[] | byref |
876 // | ptr | n.a. | | | - | | bycopy|
877 // | ptr | n.a. | - | x | - | - | bycopy|
878 // | ptr | n.a. | x | - | - | - | null |
879 // | ptr | n.a. | - | - | - | x | byref |
880 // | ptr | n.a. | - | - | - | x[] | bycopy|
881 // | ptr | n.a. | - | - | x | | bycopy|
882 // | ptr | n.a. | - | - | x | x | bycopy|
883 // | ptr | n.a. | - | - | x | x[] | bycopy|
884 // =========================================================================
890 // - - invalid in this combination
891 // [] - mapped with an array section
892 // byref - should be mapped by reference
893 // byval - should be mapped by value
894 // null - initialize a local variable to null on the device
897 // - All scalar declarations that show up in a map clause have to be passed
898 // by reference, because they may have been mapped in the enclosing data
900 // - If the scalar value does not fit the size of uintptr, it has to be
901 // passed by reference, regardless the result in the table above.
902 // - For pointers mapped by value that have either an implicit map or an
903 // array section, the runtime library may pass the NULL value to the
904 // device instead of the value passed to it by the compiler.
907 if (Ty->isReferenceType())
908 Ty = Ty->castAs<ReferenceType>()->getPointeeType();
910 // Locate map clauses and see if the variable being captured is referred to
911 // in any of those clauses. Here we only care about variables, not fields,
912 // because fields are part of aggregates.
913 bool IsVariableUsedInMapClause = false;
914 bool IsVariableAssociatedWithSection = false;
916 DSAStack->checkMappableExprComponentListsForDecl(
917 D, /*CurrentRegionOnly=*/true,
918 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
921 auto EI = MapExprComponents.rbegin();
922 auto EE = MapExprComponents.rend();
924 assert(EI != EE && "Invalid map expression!");
926 if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
927 IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
933 if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
934 isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
935 isa<MemberExpr>(EI->getAssociatedExpression())) {
936 IsVariableAssociatedWithSection = true;
937 // There is nothing more we need to know about this variable.
941 // Keep looking for more map info.
945 if (IsVariableUsedInMapClause) {
946 // If variable is identified in a map clause it is always captured by
947 // reference except if it is a pointer that is dereferenced somehow.
948 IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
950 // By default, all the data that has a scalar type is mapped by copy.
951 IsByRef = !Ty->isScalarType();
955 if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
956 IsByRef = !DSAStack->hasExplicitDSA(
957 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_firstprivate; },
958 Level, /*NotLastprivate=*/true);
961 // When passing data by copy, we need to make sure it fits the uintptr size
962 // and alignment, because the runtime library only deals with uintptr types.
963 // If it does not fit the uintptr size, we need to pass the data by reference
966 (Ctx.getTypeSizeInChars(Ty) >
967 Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
968 Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
975 unsigned Sema::getOpenMPNestingLevel() const {
976 assert(getLangOpts().OpenMP);
977 return DSAStack->getNestingLevel();
980 VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) {
981 assert(LangOpts.OpenMP && "OpenMP is not allowed");
982 D = getCanonicalDecl(D);
984 // If we are attempting to capture a global variable in a directive with
985 // 'target' we return true so that this global is also mapped to the device.
987 // FIXME: If the declaration is enclosed in a 'declare target' directive,
988 // then it should not be captured. Therefore, an extra check has to be
989 // inserted here once support for 'declare target' is added.
991 auto *VD = dyn_cast<VarDecl>(D);
992 if (VD && !VD->hasLocalStorage()) {
993 if (DSAStack->getCurrentDirective() == OMPD_target &&
994 !DSAStack->isClauseParsingMode())
996 if (DSAStack->hasDirective(
997 [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
998 SourceLocation) -> bool {
999 return isOpenMPTargetExecutionDirective(K);
1005 if (DSAStack->getCurrentDirective() != OMPD_unknown &&
1006 (!DSAStack->isClauseParsingMode() ||
1007 DSAStack->getParentDirective() != OMPD_unknown)) {
1008 auto &&Info = DSAStack->isLoopControlVariable(D);
1010 (VD && VD->hasLocalStorage() &&
1011 isParallelOrTaskRegion(DSAStack->getCurrentDirective())) ||
1012 (VD && DSAStack->isForceVarCapturing()))
1013 return VD ? VD : Info.second;
1014 auto DVarPrivate = DSAStack->getTopDSA(D, DSAStack->isClauseParsingMode());
1015 if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind))
1016 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1017 DVarPrivate = DSAStack->hasDSA(
1018 D, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
1019 DSAStack->isClauseParsingMode());
1020 if (DVarPrivate.CKind != OMPC_unknown)
1021 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1026 bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) {
1027 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1028 return DSAStack->hasExplicitDSA(
1029 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level);
1032 bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) {
1033 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1034 // Return true if the current level is no longer enclosed in a target region.
1036 auto *VD = dyn_cast<VarDecl>(D);
1037 return VD && !VD->hasLocalStorage() &&
1038 DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
1042 void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; }
1044 void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
1045 const DeclarationNameInfo &DirName,
1046 Scope *CurScope, SourceLocation Loc) {
1047 DSAStack->push(DKind, DirName, CurScope, Loc);
1048 PushExpressionEvaluationContext(PotentiallyEvaluated);
1051 void Sema::StartOpenMPClause(OpenMPClauseKind K) {
1052 DSAStack->setClauseParsingMode(K);
1055 void Sema::EndOpenMPClause() {
1056 DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown);
1059 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
1060 // OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
1061 // A variable of class type (or array thereof) that appears in a lastprivate
1062 // clause requires an accessible, unambiguous default constructor for the
1063 // class type, unless the list item is also specified in a firstprivate
1065 if (auto D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
1066 for (auto *C : D->clauses()) {
1067 if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
1068 SmallVector<Expr *, 8> PrivateCopies;
1069 for (auto *DE : Clause->varlists()) {
1070 if (DE->isValueDependent() || DE->isTypeDependent()) {
1071 PrivateCopies.push_back(nullptr);
1074 auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
1075 VarDecl *VD = cast<VarDecl>(DRE->getDecl());
1076 QualType Type = VD->getType().getNonReferenceType();
1077 auto DVar = DSAStack->getTopDSA(VD, false);
1078 if (DVar.CKind == OMPC_lastprivate) {
1079 // Generate helper private variable and initialize it with the
1080 // default value. The address of the original variable is replaced
1081 // by the address of the new private variable in CodeGen. This new
1082 // variable is not added to IdResolver, so the code in the OpenMP
1083 // region uses original variable for proper diagnostics.
1084 auto *VDPrivate = buildVarDecl(
1085 *this, DE->getExprLoc(), Type.getUnqualifiedType(),
1086 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr);
1087 ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false);
1088 if (VDPrivate->isInvalidDecl())
1090 PrivateCopies.push_back(buildDeclRefExpr(
1091 *this, VDPrivate, DE->getType(), DE->getExprLoc()));
1093 // The variable is also a firstprivate, so initialization sequence
1094 // for private copy is generated already.
1095 PrivateCopies.push_back(nullptr);
1098 // Set initializers to private copies if no errors were found.
1099 if (PrivateCopies.size() == Clause->varlist_size())
1100 Clause->setPrivateCopies(PrivateCopies);
1106 DiscardCleanupsInEvaluationContext();
1107 PopExpressionEvaluationContext();
1110 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1111 Expr *NumIterations, Sema &SemaRef,
1112 Scope *S, DSAStackTy *Stack);
1116 class VarDeclFilterCCC : public CorrectionCandidateCallback {
1121 explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
1122 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1123 NamedDecl *ND = Candidate.getCorrectionDecl();
1124 if (VarDecl *VD = dyn_cast_or_null<VarDecl>(ND)) {
1125 return VD->hasGlobalStorage() &&
1126 SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1127 SemaRef.getCurScope());
1133 class VarOrFuncDeclFilterCCC : public CorrectionCandidateCallback {
1138 explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
1139 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1140 NamedDecl *ND = Candidate.getCorrectionDecl();
1141 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
1142 return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1143 SemaRef.getCurScope());
1151 ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
1152 CXXScopeSpec &ScopeSpec,
1153 const DeclarationNameInfo &Id) {
1154 LookupResult Lookup(*this, Id, LookupOrdinaryName);
1155 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
1157 if (Lookup.isAmbiguous())
1161 if (!Lookup.isSingleResult()) {
1162 if (TypoCorrection Corrected = CorrectTypo(
1163 Id, LookupOrdinaryName, CurScope, nullptr,
1164 llvm::make_unique<VarDeclFilterCCC>(*this), CTK_ErrorRecovery)) {
1165 diagnoseTypo(Corrected,
1166 PDiag(Lookup.empty()
1167 ? diag::err_undeclared_var_use_suggest
1168 : diag::err_omp_expected_var_arg_suggest)
1170 VD = Corrected.getCorrectionDeclAs<VarDecl>();
1172 Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
1173 : diag::err_omp_expected_var_arg)
1178 if (!(VD = Lookup.getAsSingle<VarDecl>())) {
1179 Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
1180 Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
1184 Lookup.suppressDiagnostics();
1186 // OpenMP [2.9.2, Syntax, C/C++]
1187 // Variables must be file-scope, namespace-scope, or static block-scope.
1188 if (!VD->hasGlobalStorage()) {
1189 Diag(Id.getLoc(), diag::err_omp_global_var_arg)
1190 << getOpenMPDirectiveName(OMPD_threadprivate) << !VD->isStaticLocal();
1192 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1193 Diag(VD->getLocation(),
1194 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1199 VarDecl *CanonicalVD = VD->getCanonicalDecl();
1200 NamedDecl *ND = cast<NamedDecl>(CanonicalVD);
1201 // OpenMP [2.9.2, Restrictions, C/C++, p.2]
1202 // A threadprivate directive for file-scope variables must appear outside
1203 // any definition or declaration.
1204 if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
1205 !getCurLexicalContext()->isTranslationUnit()) {
1206 Diag(Id.getLoc(), diag::err_omp_var_scope)
1207 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1209 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1210 Diag(VD->getLocation(),
1211 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1215 // OpenMP [2.9.2, Restrictions, C/C++, p.3]
1216 // A threadprivate directive for static class member variables must appear
1217 // in the class definition, in the same scope in which the member
1218 // variables are declared.
1219 if (CanonicalVD->isStaticDataMember() &&
1220 !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
1221 Diag(Id.getLoc(), diag::err_omp_var_scope)
1222 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1224 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1225 Diag(VD->getLocation(),
1226 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1230 // OpenMP [2.9.2, Restrictions, C/C++, p.4]
1231 // A threadprivate directive for namespace-scope variables must appear
1232 // outside any definition or declaration other than the namespace
1233 // definition itself.
1234 if (CanonicalVD->getDeclContext()->isNamespace() &&
1235 (!getCurLexicalContext()->isFileContext() ||
1236 !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
1237 Diag(Id.getLoc(), diag::err_omp_var_scope)
1238 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1240 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1241 Diag(VD->getLocation(),
1242 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1246 // OpenMP [2.9.2, Restrictions, C/C++, p.6]
1247 // A threadprivate directive for static block-scope variables must appear
1248 // in the scope of the variable and not in a nested scope.
1249 if (CanonicalVD->isStaticLocal() && CurScope &&
1250 !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
1251 Diag(Id.getLoc(), diag::err_omp_var_scope)
1252 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1254 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1255 Diag(VD->getLocation(),
1256 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1261 // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
1262 // A threadprivate directive must lexically precede all references to any
1263 // of the variables in its list.
1264 if (VD->isUsed() && !DSAStack->isThreadPrivate(VD)) {
1265 Diag(Id.getLoc(), diag::err_omp_var_used)
1266 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1270 QualType ExprType = VD->getType().getNonReferenceType();
1271 return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
1272 SourceLocation(), VD,
1273 /*RefersToEnclosingVariableOrCapture=*/false,
1274 Id.getLoc(), ExprType, VK_LValue);
1277 Sema::DeclGroupPtrTy
1278 Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
1279 ArrayRef<Expr *> VarList) {
1280 if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
1281 CurContext->addDecl(D);
1282 return DeclGroupPtrTy::make(DeclGroupRef(D));
1288 class LocalVarRefChecker : public ConstStmtVisitor<LocalVarRefChecker, bool> {
1292 bool VisitDeclRefExpr(const DeclRefExpr *E) {
1293 if (auto VD = dyn_cast<VarDecl>(E->getDecl())) {
1294 if (VD->hasLocalStorage()) {
1295 SemaRef.Diag(E->getLocStart(),
1296 diag::err_omp_local_var_in_threadprivate_init)
1297 << E->getSourceRange();
1298 SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
1299 << VD << VD->getSourceRange();
1305 bool VisitStmt(const Stmt *S) {
1306 for (auto Child : S->children()) {
1307 if (Child && Visit(Child))
1312 explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
1316 OMPThreadPrivateDecl *
1317 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
1318 SmallVector<Expr *, 8> Vars;
1319 for (auto &RefExpr : VarList) {
1320 DeclRefExpr *DE = cast<DeclRefExpr>(RefExpr);
1321 VarDecl *VD = cast<VarDecl>(DE->getDecl());
1322 SourceLocation ILoc = DE->getExprLoc();
1324 // Mark variable as used.
1325 VD->setReferenced();
1326 VD->markUsed(Context);
1328 QualType QType = VD->getType();
1329 if (QType->isDependentType() || QType->isInstantiationDependentType()) {
1330 // It will be analyzed later.
1335 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1336 // A threadprivate variable must not have an incomplete type.
1337 if (RequireCompleteType(ILoc, VD->getType(),
1338 diag::err_omp_threadprivate_incomplete_type)) {
1342 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1343 // A threadprivate variable must not have a reference type.
1344 if (VD->getType()->isReferenceType()) {
1345 Diag(ILoc, diag::err_omp_ref_type_arg)
1346 << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
1348 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1349 Diag(VD->getLocation(),
1350 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1355 // Check if this is a TLS variable. If TLS is not being supported, produce
1356 // the corresponding diagnostic.
1357 if ((VD->getTLSKind() != VarDecl::TLS_None &&
1358 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
1359 getLangOpts().OpenMPUseTLS &&
1360 getASTContext().getTargetInfo().isTLSSupported())) ||
1361 (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
1362 !VD->isLocalVarDecl())) {
1363 Diag(ILoc, diag::err_omp_var_thread_local)
1364 << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
1366 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1367 Diag(VD->getLocation(),
1368 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1373 // Check if initial value of threadprivate variable reference variable with
1374 // local storage (it is not supported by runtime).
1375 if (auto Init = VD->getAnyInitializer()) {
1376 LocalVarRefChecker Checker(*this);
1377 if (Checker.Visit(Init))
1381 Vars.push_back(RefExpr);
1382 DSAStack->addDSA(VD, DE, OMPC_threadprivate);
1383 VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
1384 Context, SourceRange(Loc, Loc)));
1385 if (auto *ML = Context.getASTMutationListener())
1386 ML->DeclarationMarkedOpenMPThreadPrivate(VD);
1388 OMPThreadPrivateDecl *D = nullptr;
1389 if (!Vars.empty()) {
1390 D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
1392 D->setAccess(AS_public);
1397 static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack,
1398 const ValueDecl *D, DSAStackTy::DSAVarData DVar,
1399 bool IsLoopIterVar = false) {
1401 SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
1402 << getOpenMPClauseName(DVar.CKind);
1406 PDSA_StaticMemberShared,
1407 PDSA_StaticLocalVarShared,
1408 PDSA_LoopIterVarPrivate,
1409 PDSA_LoopIterVarLinear,
1410 PDSA_LoopIterVarLastprivate,
1411 PDSA_ConstVarShared,
1412 PDSA_GlobalVarShared,
1413 PDSA_TaskVarFirstprivate,
1414 PDSA_LocalVarPrivate,
1416 } Reason = PDSA_Implicit;
1417 bool ReportHint = false;
1418 auto ReportLoc = D->getLocation();
1419 auto *VD = dyn_cast<VarDecl>(D);
1420 if (IsLoopIterVar) {
1421 if (DVar.CKind == OMPC_private)
1422 Reason = PDSA_LoopIterVarPrivate;
1423 else if (DVar.CKind == OMPC_lastprivate)
1424 Reason = PDSA_LoopIterVarLastprivate;
1426 Reason = PDSA_LoopIterVarLinear;
1427 } else if (isOpenMPTaskingDirective(DVar.DKind) &&
1428 DVar.CKind == OMPC_firstprivate) {
1429 Reason = PDSA_TaskVarFirstprivate;
1430 ReportLoc = DVar.ImplicitDSALoc;
1431 } else if (VD && VD->isStaticLocal())
1432 Reason = PDSA_StaticLocalVarShared;
1433 else if (VD && VD->isStaticDataMember())
1434 Reason = PDSA_StaticMemberShared;
1435 else if (VD && VD->isFileVarDecl())
1436 Reason = PDSA_GlobalVarShared;
1437 else if (D->getType().isConstant(SemaRef.getASTContext()))
1438 Reason = PDSA_ConstVarShared;
1439 else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
1441 Reason = PDSA_LocalVarPrivate;
1443 if (Reason != PDSA_Implicit) {
1444 SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
1445 << Reason << ReportHint
1446 << getOpenMPDirectiveName(Stack->getCurrentDirective());
1447 } else if (DVar.ImplicitDSALoc.isValid()) {
1448 SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
1449 << getOpenMPClauseName(DVar.CKind);
1454 class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> {
1459 llvm::SmallVector<Expr *, 8> ImplicitFirstprivate;
1460 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
1463 void VisitDeclRefExpr(DeclRefExpr *E) {
1464 if (E->isTypeDependent() || E->isValueDependent() ||
1465 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1467 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1468 // Skip internally declared variables.
1469 if (VD->isLocalVarDecl() && !CS->capturesVariable(VD))
1472 auto DVar = Stack->getTopDSA(VD, false);
1473 // Check if the variable has explicit DSA set and stop analysis if it so.
1474 if (DVar.RefExpr) return;
1476 auto ELoc = E->getExprLoc();
1477 auto DKind = Stack->getCurrentDirective();
1478 // The default(none) clause requires that each variable that is referenced
1479 // in the construct, and does not have a predetermined data-sharing
1480 // attribute, must have its data-sharing attribute explicitly determined
1481 // by being listed in a data-sharing attribute clause.
1482 if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none &&
1483 isParallelOrTaskRegion(DKind) &&
1484 VarsWithInheritedDSA.count(VD) == 0) {
1485 VarsWithInheritedDSA[VD] = E;
1489 // OpenMP [2.9.3.6, Restrictions, p.2]
1490 // A list item that appears in a reduction clause of the innermost
1491 // enclosing worksharing or parallel construct may not be accessed in an
1493 DVar = Stack->hasInnermostDSA(
1494 VD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1495 [](OpenMPDirectiveKind K) -> bool {
1496 return isOpenMPParallelDirective(K) ||
1497 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
1500 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1502 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1503 ReportOriginalDSA(SemaRef, Stack, VD, DVar);
1507 // Define implicit data-sharing attributes for task.
1508 DVar = Stack->getImplicitDSA(VD, false);
1509 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1510 !Stack->isLoopControlVariable(VD).first)
1511 ImplicitFirstprivate.push_back(E);
1514 void VisitMemberExpr(MemberExpr *E) {
1515 if (E->isTypeDependent() || E->isValueDependent() ||
1516 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1518 if (isa<CXXThisExpr>(E->getBase()->IgnoreParens())) {
1519 if (auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
1520 auto DVar = Stack->getTopDSA(FD, false);
1521 // Check if the variable has explicit DSA set and stop analysis if it
1526 auto ELoc = E->getExprLoc();
1527 auto DKind = Stack->getCurrentDirective();
1528 // OpenMP [2.9.3.6, Restrictions, p.2]
1529 // A list item that appears in a reduction clause of the innermost
1530 // enclosing worksharing or parallel construct may not be accessed in
1531 // an explicit task.
1532 DVar = Stack->hasInnermostDSA(
1533 FD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1534 [](OpenMPDirectiveKind K) -> bool {
1535 return isOpenMPParallelDirective(K) ||
1536 isOpenMPWorksharingDirective(K) ||
1537 isOpenMPTeamsDirective(K);
1540 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1542 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1543 ReportOriginalDSA(SemaRef, Stack, FD, DVar);
1547 // Define implicit data-sharing attributes for task.
1548 DVar = Stack->getImplicitDSA(FD, false);
1549 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1550 !Stack->isLoopControlVariable(FD).first)
1551 ImplicitFirstprivate.push_back(E);
1555 void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
1556 for (auto *C : S->clauses()) {
1557 // Skip analysis of arguments of implicitly defined firstprivate clause
1558 // for task directives.
1559 if (C && (!isa<OMPFirstprivateClause>(C) || C->getLocStart().isValid()))
1560 for (auto *CC : C->children()) {
1566 void VisitStmt(Stmt *S) {
1567 for (auto *C : S->children()) {
1568 if (C && !isa<OMPExecutableDirective>(C))
1573 bool isErrorFound() { return ErrorFound; }
1574 ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; }
1575 llvm::DenseMap<ValueDecl *, Expr *> &getVarsWithInheritedDSA() {
1576 return VarsWithInheritedDSA;
1579 DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
1580 : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {}
1584 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
1587 case OMPD_parallel_for:
1588 case OMPD_parallel_for_simd:
1589 case OMPD_parallel_sections:
1591 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1592 QualType KmpInt32PtrTy =
1593 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1594 Sema::CapturedParamNameType Params[] = {
1595 std::make_pair(".global_tid.", KmpInt32PtrTy),
1596 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1597 std::make_pair(StringRef(), QualType()) // __context with shared vars
1599 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1611 case OMPD_taskgroup:
1612 case OMPD_distribute:
1615 case OMPD_target_data:
1617 case OMPD_target_parallel:
1618 case OMPD_target_parallel_for:
1619 case OMPD_target_parallel_for_simd: {
1620 Sema::CapturedParamNameType Params[] = {
1621 std::make_pair(StringRef(), QualType()) // __context with shared vars
1623 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1628 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1629 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1630 FunctionProtoType::ExtProtoInfo EPI;
1631 EPI.Variadic = true;
1632 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1633 Sema::CapturedParamNameType Params[] = {
1634 std::make_pair(".global_tid.", KmpInt32Ty),
1635 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1636 std::make_pair(".privates.", Context.VoidPtrTy.withConst()),
1637 std::make_pair(".copy_fn.",
1638 Context.getPointerType(CopyFnType).withConst()),
1639 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1640 std::make_pair(StringRef(), QualType()) // __context with shared vars
1642 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1644 // Mark this captured region as inlined, because we don't use outlined
1645 // function directly.
1646 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1647 AlwaysInlineAttr::CreateImplicit(
1648 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1652 case OMPD_taskloop_simd: {
1653 QualType KmpInt32Ty =
1654 Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
1655 QualType KmpUInt64Ty =
1656 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
1657 QualType KmpInt64Ty =
1658 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
1659 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1660 FunctionProtoType::ExtProtoInfo EPI;
1661 EPI.Variadic = true;
1662 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1663 Sema::CapturedParamNameType Params[] = {
1664 std::make_pair(".global_tid.", KmpInt32Ty),
1665 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1666 std::make_pair(".privates.",
1667 Context.VoidPtrTy.withConst().withRestrict()),
1670 Context.getPointerType(CopyFnType).withConst().withRestrict()),
1671 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1672 std::make_pair(".lb.", KmpUInt64Ty),
1673 std::make_pair(".ub.", KmpUInt64Ty), std::make_pair(".st.", KmpInt64Ty),
1674 std::make_pair(".liter.", KmpInt32Ty),
1675 std::make_pair(StringRef(), QualType()) // __context with shared vars
1677 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1679 // Mark this captured region as inlined, because we don't use outlined
1680 // function directly.
1681 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1682 AlwaysInlineAttr::CreateImplicit(
1683 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1686 case OMPD_distribute_parallel_for_simd:
1687 case OMPD_distribute_simd:
1688 case OMPD_distribute_parallel_for: {
1689 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1690 QualType KmpInt32PtrTy =
1691 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1692 Sema::CapturedParamNameType Params[] = {
1693 std::make_pair(".global_tid.", KmpInt32PtrTy),
1694 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1695 std::make_pair(".previous.lb.", Context.getSizeType()),
1696 std::make_pair(".previous.ub.", Context.getSizeType()),
1697 std::make_pair(StringRef(), QualType()) // __context with shared vars
1699 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1703 case OMPD_threadprivate:
1704 case OMPD_taskyield:
1707 case OMPD_cancellation_point:
1710 case OMPD_target_enter_data:
1711 case OMPD_target_exit_data:
1712 case OMPD_declare_reduction:
1713 case OMPD_declare_simd:
1714 case OMPD_declare_target:
1715 case OMPD_end_declare_target:
1716 case OMPD_target_update:
1717 llvm_unreachable("OpenMP Directive is not allowed");
1719 llvm_unreachable("Unknown OpenMP directive");
1723 static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id,
1724 Expr *CaptureExpr, bool WithInit,
1725 bool AsExpression) {
1726 assert(CaptureExpr);
1727 ASTContext &C = S.getASTContext();
1728 Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
1729 QualType Ty = Init->getType();
1730 if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) {
1731 if (S.getLangOpts().CPlusPlus)
1732 Ty = C.getLValueReferenceType(Ty);
1734 Ty = C.getPointerType(Ty);
1736 S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init);
1737 if (!Res.isUsable())
1743 auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty);
1745 CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C, SourceRange()));
1746 S.CurContext->addHiddenDecl(CED);
1747 S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false,
1748 /*TypeMayContainAuto=*/true);
1752 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
1754 OMPCapturedExprDecl *CD;
1755 if (auto *VD = S.IsOpenMPCapturedDecl(D))
1756 CD = cast<OMPCapturedExprDecl>(VD);
1758 CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit,
1759 /*AsExpression=*/false);
1760 return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1761 CaptureExpr->getExprLoc());
1764 static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) {
1767 buildCaptureDecl(S, &S.getASTContext().Idents.get(".capture_expr."),
1768 CaptureExpr, /*WithInit=*/true, /*AsExpression=*/true);
1769 Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1770 CaptureExpr->getExprLoc());
1772 ExprResult Res = Ref;
1773 if (!S.getLangOpts().CPlusPlus &&
1774 CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() &&
1775 Ref->getType()->isPointerType())
1776 Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref);
1777 if (!Res.isUsable())
1779 return CaptureExpr->isGLValue() ? Res : S.DefaultLvalueConversion(Res.get());
1782 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
1783 ArrayRef<OMPClause *> Clauses) {
1784 if (!S.isUsable()) {
1785 ActOnCapturedRegionError();
1789 OMPOrderedClause *OC = nullptr;
1790 OMPScheduleClause *SC = nullptr;
1791 SmallVector<OMPLinearClause *, 4> LCs;
1792 // This is required for proper codegen.
1793 for (auto *Clause : Clauses) {
1794 if (isOpenMPPrivate(Clause->getClauseKind()) ||
1795 Clause->getClauseKind() == OMPC_copyprivate ||
1796 (getLangOpts().OpenMPUseTLS &&
1797 getASTContext().getTargetInfo().isTLSSupported() &&
1798 Clause->getClauseKind() == OMPC_copyin)) {
1799 DSAStack->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin);
1800 // Mark all variables in private list clauses as used in inner region.
1801 for (auto *VarRef : Clause->children()) {
1802 if (auto *E = cast_or_null<Expr>(VarRef)) {
1803 MarkDeclarationsReferencedInExpr(E);
1806 DSAStack->setForceVarCapturing(/*V=*/false);
1807 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective())) {
1808 // Mark all variables in private list clauses as used in inner region.
1809 // Required for proper codegen of combined directives.
1810 // TODO: add processing for other clauses.
1811 if (auto *C = OMPClauseWithPreInit::get(Clause)) {
1812 if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
1813 for (auto *D : DS->decls())
1814 MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
1817 if (auto *C = OMPClauseWithPostUpdate::get(Clause)) {
1818 if (auto *E = C->getPostUpdateExpr())
1819 MarkDeclarationsReferencedInExpr(E);
1822 if (Clause->getClauseKind() == OMPC_schedule)
1823 SC = cast<OMPScheduleClause>(Clause);
1824 else if (Clause->getClauseKind() == OMPC_ordered)
1825 OC = cast<OMPOrderedClause>(Clause);
1826 else if (Clause->getClauseKind() == OMPC_linear)
1827 LCs.push_back(cast<OMPLinearClause>(Clause));
1829 bool ErrorFound = false;
1830 // OpenMP, 2.7.1 Loop Construct, Restrictions
1831 // The nonmonotonic modifier cannot be specified if an ordered clause is
1834 (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
1835 SC->getSecondScheduleModifier() ==
1836 OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
1838 Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
1839 ? SC->getFirstScheduleModifierLoc()
1840 : SC->getSecondScheduleModifierLoc(),
1841 diag::err_omp_schedule_nonmonotonic_ordered)
1842 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1845 if (!LCs.empty() && OC && OC->getNumForLoops()) {
1846 for (auto *C : LCs) {
1847 Diag(C->getLocStart(), diag::err_omp_linear_ordered)
1848 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1852 if (isOpenMPWorksharingDirective(DSAStack->getCurrentDirective()) &&
1853 isOpenMPSimdDirective(DSAStack->getCurrentDirective()) && OC &&
1854 OC->getNumForLoops()) {
1855 Diag(OC->getLocStart(), diag::err_omp_ordered_simd)
1856 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
1860 ActOnCapturedRegionError();
1863 return ActOnCapturedRegionEnd(S.get());
1866 static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack,
1867 OpenMPDirectiveKind CurrentRegion,
1868 const DeclarationNameInfo &CurrentName,
1869 OpenMPDirectiveKind CancelRegion,
1870 SourceLocation StartLoc) {
1871 // Allowed nesting of constructs
1872 // +------------------+-----------------+------------------------------------+
1873 // | Parent directive | Child directive | Closely (!), No-Closely(+), Both(*)|
1874 // +------------------+-----------------+------------------------------------+
1875 // | parallel | parallel | * |
1876 // | parallel | for | * |
1877 // | parallel | for simd | * |
1878 // | parallel | master | * |
1879 // | parallel | critical | * |
1880 // | parallel | simd | * |
1881 // | parallel | sections | * |
1882 // | parallel | section | + |
1883 // | parallel | single | * |
1884 // | parallel | parallel for | * |
1885 // | parallel |parallel for simd| * |
1886 // | parallel |parallel sections| * |
1887 // | parallel | task | * |
1888 // | parallel | taskyield | * |
1889 // | parallel | barrier | * |
1890 // | parallel | taskwait | * |
1891 // | parallel | taskgroup | * |
1892 // | parallel | flush | * |
1893 // | parallel | ordered | + |
1894 // | parallel | atomic | * |
1895 // | parallel | target | * |
1896 // | parallel | target parallel | * |
1897 // | parallel | target parallel | * |
1899 // | parallel | target enter | * |
1901 // | parallel | target exit | * |
1903 // | parallel | teams | + |
1904 // | parallel | cancellation | |
1906 // | parallel | cancel | ! |
1907 // | parallel | taskloop | * |
1908 // | parallel | taskloop simd | * |
1909 // | parallel | distribute | + |
1910 // | parallel | distribute | + |
1911 // | | parallel for | |
1912 // | parallel | distribute | + |
1913 // | |parallel for simd| |
1914 // | parallel | distribute simd | + |
1915 // +------------------+-----------------+------------------------------------+
1916 // | for | parallel | * |
1917 // | for | for | + |
1918 // | for | for simd | + |
1919 // | for | master | + |
1920 // | for | critical | * |
1921 // | for | simd | * |
1922 // | for | sections | + |
1923 // | for | section | + |
1924 // | for | single | + |
1925 // | for | parallel for | * |
1926 // | for |parallel for simd| * |
1927 // | for |parallel sections| * |
1928 // | for | task | * |
1929 // | for | taskyield | * |
1930 // | for | barrier | + |
1931 // | for | taskwait | * |
1932 // | for | taskgroup | * |
1933 // | for | flush | * |
1934 // | for | ordered | * (if construct is ordered) |
1935 // | for | atomic | * |
1936 // | for | target | * |
1937 // | for | target parallel | * |
1938 // | for | target parallel | * |
1940 // | for | target enter | * |
1942 // | for | target exit | * |
1944 // | for | teams | + |
1945 // | for | cancellation | |
1947 // | for | cancel | ! |
1948 // | for | taskloop | * |
1949 // | for | taskloop simd | * |
1950 // | for | distribute | + |
1951 // | for | distribute | + |
1952 // | | parallel for | |
1953 // | for | distribute | + |
1954 // | |parallel for simd| |
1955 // | for | distribute simd | + |
1956 // | for | target parallel | + |
1958 // +------------------+-----------------+------------------------------------+
1959 // | master | parallel | * |
1960 // | master | for | + |
1961 // | master | for simd | + |
1962 // | master | master | * |
1963 // | master | critical | * |
1964 // | master | simd | * |
1965 // | master | sections | + |
1966 // | master | section | + |
1967 // | master | single | + |
1968 // | master | parallel for | * |
1969 // | master |parallel for simd| * |
1970 // | master |parallel sections| * |
1971 // | master | task | * |
1972 // | master | taskyield | * |
1973 // | master | barrier | + |
1974 // | master | taskwait | * |
1975 // | master | taskgroup | * |
1976 // | master | flush | * |
1977 // | master | ordered | + |
1978 // | master | atomic | * |
1979 // | master | target | * |
1980 // | master | target parallel | * |
1981 // | master | target parallel | * |
1983 // | master | target enter | * |
1985 // | master | target exit | * |
1987 // | master | teams | + |
1988 // | master | cancellation | |
1990 // | master | cancel | |
1991 // | master | taskloop | * |
1992 // | master | taskloop simd | * |
1993 // | master | distribute | + |
1994 // | master | distribute | + |
1995 // | | parallel for | |
1996 // | master | distribute | + |
1997 // | |parallel for simd| |
1998 // | master | distribute simd | + |
1999 // | master | target parallel | + |
2001 // +------------------+-----------------+------------------------------------+
2002 // | critical | parallel | * |
2003 // | critical | for | + |
2004 // | critical | for simd | + |
2005 // | critical | master | * |
2006 // | critical | critical | * (should have different names) |
2007 // | critical | simd | * |
2008 // | critical | sections | + |
2009 // | critical | section | + |
2010 // | critical | single | + |
2011 // | critical | parallel for | * |
2012 // | critical |parallel for simd| * |
2013 // | critical |parallel sections| * |
2014 // | critical | task | * |
2015 // | critical | taskyield | * |
2016 // | critical | barrier | + |
2017 // | critical | taskwait | * |
2018 // | critical | taskgroup | * |
2019 // | critical | ordered | + |
2020 // | critical | atomic | * |
2021 // | critical | target | * |
2022 // | critical | target parallel | * |
2023 // | critical | target parallel | * |
2025 // | critical | target enter | * |
2027 // | critical | target exit | * |
2029 // | critical | teams | + |
2030 // | critical | cancellation | |
2032 // | critical | cancel | |
2033 // | critical | taskloop | * |
2034 // | critical | taskloop simd | * |
2035 // | critical | distribute | + |
2036 // | critical | distribute | + |
2037 // | | parallel for | |
2038 // | critical | distribute | + |
2039 // | |parallel for simd| |
2040 // | critical | distribute simd | + |
2041 // | critical | target parallel | + |
2043 // +------------------+-----------------+------------------------------------+
2044 // | simd | parallel | |
2046 // | simd | for simd | |
2047 // | simd | master | |
2048 // | simd | critical | |
2049 // | simd | simd | * |
2050 // | simd | sections | |
2051 // | simd | section | |
2052 // | simd | single | |
2053 // | simd | parallel for | |
2054 // | simd |parallel for simd| |
2055 // | simd |parallel sections| |
2056 // | simd | task | |
2057 // | simd | taskyield | |
2058 // | simd | barrier | |
2059 // | simd | taskwait | |
2060 // | simd | taskgroup | |
2061 // | simd | flush | |
2062 // | simd | ordered | + (with simd clause) |
2063 // | simd | atomic | |
2064 // | simd | target | |
2065 // | simd | target parallel | |
2066 // | simd | target parallel | |
2068 // | simd | target enter | |
2070 // | simd | target exit | |
2072 // | simd | teams | |
2073 // | simd | cancellation | |
2075 // | simd | cancel | |
2076 // | simd | taskloop | |
2077 // | simd | taskloop simd | |
2078 // | simd | distribute | |
2079 // | simd | distribute | |
2080 // | | parallel for | |
2081 // | simd | distribute | |
2082 // | |parallel for simd| |
2083 // | simd | distribute simd | |
2084 // | simd | target parallel | |
2086 // +------------------+-----------------+------------------------------------+
2087 // | for simd | parallel | |
2088 // | for simd | for | |
2089 // | for simd | for simd | |
2090 // | for simd | master | |
2091 // | for simd | critical | |
2092 // | for simd | simd | * |
2093 // | for simd | sections | |
2094 // | for simd | section | |
2095 // | for simd | single | |
2096 // | for simd | parallel for | |
2097 // | for simd |parallel for simd| |
2098 // | for simd |parallel sections| |
2099 // | for simd | task | |
2100 // | for simd | taskyield | |
2101 // | for simd | barrier | |
2102 // | for simd | taskwait | |
2103 // | for simd | taskgroup | |
2104 // | for simd | flush | |
2105 // | for simd | ordered | + (with simd clause) |
2106 // | for simd | atomic | |
2107 // | for simd | target | |
2108 // | for simd | target parallel | |
2109 // | for simd | target parallel | |
2111 // | for simd | target enter | |
2113 // | for simd | target exit | |
2115 // | for simd | teams | |
2116 // | for simd | cancellation | |
2118 // | for simd | cancel | |
2119 // | for simd | taskloop | |
2120 // | for simd | taskloop simd | |
2121 // | for simd | distribute | |
2122 // | for simd | distribute | |
2123 // | | parallel for | |
2124 // | for simd | distribute | |
2125 // | |parallel for simd| |
2126 // | for simd | distribute simd | |
2127 // | for simd | target parallel | |
2129 // +------------------+-----------------+------------------------------------+
2130 // | parallel for simd| parallel | |
2131 // | parallel for simd| for | |
2132 // | parallel for simd| for simd | |
2133 // | parallel for simd| master | |
2134 // | parallel for simd| critical | |
2135 // | parallel for simd| simd | * |
2136 // | parallel for simd| sections | |
2137 // | parallel for simd| section | |
2138 // | parallel for simd| single | |
2139 // | parallel for simd| parallel for | |
2140 // | parallel for simd|parallel for simd| |
2141 // | parallel for simd|parallel sections| |
2142 // | parallel for simd| task | |
2143 // | parallel for simd| taskyield | |
2144 // | parallel for simd| barrier | |
2145 // | parallel for simd| taskwait | |
2146 // | parallel for simd| taskgroup | |
2147 // | parallel for simd| flush | |
2148 // | parallel for simd| ordered | + (with simd clause) |
2149 // | parallel for simd| atomic | |
2150 // | parallel for simd| target | |
2151 // | parallel for simd| target parallel | |
2152 // | parallel for simd| target parallel | |
2154 // | parallel for simd| target enter | |
2156 // | parallel for simd| target exit | |
2158 // | parallel for simd| teams | |
2159 // | parallel for simd| cancellation | |
2161 // | parallel for simd| cancel | |
2162 // | parallel for simd| taskloop | |
2163 // | parallel for simd| taskloop simd | |
2164 // | parallel for simd| distribute | |
2165 // | parallel for simd| distribute | |
2166 // | | parallel for | |
2167 // | parallel for simd| distribute | |
2168 // | |parallel for simd| |
2169 // | parallel for simd| distribute simd | |
2171 // +------------------+-----------------+------------------------------------+
2172 // | sections | parallel | * |
2173 // | sections | for | + |
2174 // | sections | for simd | + |
2175 // | sections | master | + |
2176 // | sections | critical | * |
2177 // | sections | simd | * |
2178 // | sections | sections | + |
2179 // | sections | section | * |
2180 // | sections | single | + |
2181 // | sections | parallel for | * |
2182 // | sections |parallel for simd| * |
2183 // | sections |parallel sections| * |
2184 // | sections | task | * |
2185 // | sections | taskyield | * |
2186 // | sections | barrier | + |
2187 // | sections | taskwait | * |
2188 // | sections | taskgroup | * |
2189 // | sections | flush | * |
2190 // | sections | ordered | + |
2191 // | sections | atomic | * |
2192 // | sections | target | * |
2193 // | sections | target parallel | * |
2194 // | sections | target parallel | * |
2196 // | sections | target enter | * |
2198 // | sections | target exit | * |
2200 // | sections | teams | + |
2201 // | sections | cancellation | |
2203 // | sections | cancel | ! |
2204 // | sections | taskloop | * |
2205 // | sections | taskloop simd | * |
2206 // | sections | distribute | + |
2207 // | sections | distribute | + |
2208 // | | parallel for | |
2209 // | sections | distribute | + |
2210 // | |parallel for simd| |
2211 // | sections | distribute simd | + |
2212 // | sections | target parallel | + |
2214 // +------------------+-----------------+------------------------------------+
2215 // | section | parallel | * |
2216 // | section | for | + |
2217 // | section | for simd | + |
2218 // | section | master | + |
2219 // | section | critical | * |
2220 // | section | simd | * |
2221 // | section | sections | + |
2222 // | section | section | + |
2223 // | section | single | + |
2224 // | section | parallel for | * |
2225 // | section |parallel for simd| * |
2226 // | section |parallel sections| * |
2227 // | section | task | * |
2228 // | section | taskyield | * |
2229 // | section | barrier | + |
2230 // | section | taskwait | * |
2231 // | section | taskgroup | * |
2232 // | section | flush | * |
2233 // | section | ordered | + |
2234 // | section | atomic | * |
2235 // | section | target | * |
2236 // | section | target parallel | * |
2237 // | section | target parallel | * |
2239 // | section | target enter | * |
2241 // | section | target exit | * |
2243 // | section | teams | + |
2244 // | section | cancellation | |
2246 // | section | cancel | ! |
2247 // | section | taskloop | * |
2248 // | section | taskloop simd | * |
2249 // | section | distribute | + |
2250 // | section | distribute | + |
2251 // | | parallel for | |
2252 // | section | distribute | + |
2253 // | |parallel for simd| |
2254 // | section | distribute simd | + |
2255 // | section | target parallel | + |
2257 // +------------------+-----------------+------------------------------------+
2258 // | single | parallel | * |
2259 // | single | for | + |
2260 // | single | for simd | + |
2261 // | single | master | + |
2262 // | single | critical | * |
2263 // | single | simd | * |
2264 // | single | sections | + |
2265 // | single | section | + |
2266 // | single | single | + |
2267 // | single | parallel for | * |
2268 // | single |parallel for simd| * |
2269 // | single |parallel sections| * |
2270 // | single | task | * |
2271 // | single | taskyield | * |
2272 // | single | barrier | + |
2273 // | single | taskwait | * |
2274 // | single | taskgroup | * |
2275 // | single | flush | * |
2276 // | single | ordered | + |
2277 // | single | atomic | * |
2278 // | single | target | * |
2279 // | single | target parallel | * |
2280 // | single | target parallel | * |
2282 // | single | target enter | * |
2284 // | single | target exit | * |
2286 // | single | teams | + |
2287 // | single | cancellation | |
2289 // | single | cancel | |
2290 // | single | taskloop | * |
2291 // | single | taskloop simd | * |
2292 // | single | distribute | + |
2293 // | single | distribute | + |
2294 // | | parallel for | |
2295 // | single | distribute | + |
2296 // | |parallel for simd| |
2297 // | single | distribute simd | + |
2298 // | single | target parallel | + |
2300 // +------------------+-----------------+------------------------------------+
2301 // | parallel for | parallel | * |
2302 // | parallel for | for | + |
2303 // | parallel for | for simd | + |
2304 // | parallel for | master | + |
2305 // | parallel for | critical | * |
2306 // | parallel for | simd | * |
2307 // | parallel for | sections | + |
2308 // | parallel for | section | + |
2309 // | parallel for | single | + |
2310 // | parallel for | parallel for | * |
2311 // | parallel for |parallel for simd| * |
2312 // | parallel for |parallel sections| * |
2313 // | parallel for | task | * |
2314 // | parallel for | taskyield | * |
2315 // | parallel for | barrier | + |
2316 // | parallel for | taskwait | * |
2317 // | parallel for | taskgroup | * |
2318 // | parallel for | flush | * |
2319 // | parallel for | ordered | * (if construct is ordered) |
2320 // | parallel for | atomic | * |
2321 // | parallel for | target | * |
2322 // | parallel for | target parallel | * |
2323 // | parallel for | target parallel | * |
2325 // | parallel for | target enter | * |
2327 // | parallel for | target exit | * |
2329 // | parallel for | teams | + |
2330 // | parallel for | cancellation | |
2332 // | parallel for | cancel | ! |
2333 // | parallel for | taskloop | * |
2334 // | parallel for | taskloop simd | * |
2335 // | parallel for | distribute | + |
2336 // | parallel for | distribute | + |
2337 // | | parallel for | |
2338 // | parallel for | distribute | + |
2339 // | |parallel for simd| |
2340 // | parallel for | distribute simd | + |
2341 // | parallel for | target parallel | + |
2343 // +------------------+-----------------+------------------------------------+
2344 // | parallel sections| parallel | * |
2345 // | parallel sections| for | + |
2346 // | parallel sections| for simd | + |
2347 // | parallel sections| master | + |
2348 // | parallel sections| critical | + |
2349 // | parallel sections| simd | * |
2350 // | parallel sections| sections | + |
2351 // | parallel sections| section | * |
2352 // | parallel sections| single | + |
2353 // | parallel sections| parallel for | * |
2354 // | parallel sections|parallel for simd| * |
2355 // | parallel sections|parallel sections| * |
2356 // | parallel sections| task | * |
2357 // | parallel sections| taskyield | * |
2358 // | parallel sections| barrier | + |
2359 // | parallel sections| taskwait | * |
2360 // | parallel sections| taskgroup | * |
2361 // | parallel sections| flush | * |
2362 // | parallel sections| ordered | + |
2363 // | parallel sections| atomic | * |
2364 // | parallel sections| target | * |
2365 // | parallel sections| target parallel | * |
2366 // | parallel sections| target parallel | * |
2368 // | parallel sections| target enter | * |
2370 // | parallel sections| target exit | * |
2372 // | parallel sections| teams | + |
2373 // | parallel sections| cancellation | |
2375 // | parallel sections| cancel | ! |
2376 // | parallel sections| taskloop | * |
2377 // | parallel sections| taskloop simd | * |
2378 // | parallel sections| distribute | + |
2379 // | parallel sections| distribute | + |
2380 // | | parallel for | |
2381 // | parallel sections| distribute | + |
2382 // | |parallel for simd| |
2383 // | parallel sections| distribute simd | + |
2384 // | parallel sections| target parallel | + |
2386 // +------------------+-----------------+------------------------------------+
2387 // | task | parallel | * |
2388 // | task | for | + |
2389 // | task | for simd | + |
2390 // | task | master | + |
2391 // | task | critical | * |
2392 // | task | simd | * |
2393 // | task | sections | + |
2394 // | task | section | + |
2395 // | task | single | + |
2396 // | task | parallel for | * |
2397 // | task |parallel for simd| * |
2398 // | task |parallel sections| * |
2399 // | task | task | * |
2400 // | task | taskyield | * |
2401 // | task | barrier | + |
2402 // | task | taskwait | * |
2403 // | task | taskgroup | * |
2404 // | task | flush | * |
2405 // | task | ordered | + |
2406 // | task | atomic | * |
2407 // | task | target | * |
2408 // | task | target parallel | * |
2409 // | task | target parallel | * |
2411 // | task | target enter | * |
2413 // | task | target exit | * |
2415 // | task | teams | + |
2416 // | task | cancellation | |
2418 // | task | cancel | ! |
2419 // | task | taskloop | * |
2420 // | task | taskloop simd | * |
2421 // | task | distribute | + |
2422 // | task | distribute | + |
2423 // | | parallel for | |
2424 // | task | distribute | + |
2425 // | |parallel for simd| |
2426 // | task | distribute simd | + |
2427 // | task | target parallel | + |
2429 // +------------------+-----------------+------------------------------------+
2430 // | ordered | parallel | * |
2431 // | ordered | for | + |
2432 // | ordered | for simd | + |
2433 // | ordered | master | * |
2434 // | ordered | critical | * |
2435 // | ordered | simd | * |
2436 // | ordered | sections | + |
2437 // | ordered | section | + |
2438 // | ordered | single | + |
2439 // | ordered | parallel for | * |
2440 // | ordered |parallel for simd| * |
2441 // | ordered |parallel sections| * |
2442 // | ordered | task | * |
2443 // | ordered | taskyield | * |
2444 // | ordered | barrier | + |
2445 // | ordered | taskwait | * |
2446 // | ordered | taskgroup | * |
2447 // | ordered | flush | * |
2448 // | ordered | ordered | + |
2449 // | ordered | atomic | * |
2450 // | ordered | target | * |
2451 // | ordered | target parallel | * |
2452 // | ordered | target parallel | * |
2454 // | ordered | target enter | * |
2456 // | ordered | target exit | * |
2458 // | ordered | teams | + |
2459 // | ordered | cancellation | |
2461 // | ordered | cancel | |
2462 // | ordered | taskloop | * |
2463 // | ordered | taskloop simd | * |
2464 // | ordered | distribute | + |
2465 // | ordered | distribute | + |
2466 // | | parallel for | |
2467 // | ordered | distribute | + |
2468 // | |parallel for simd| |
2469 // | ordered | distribute simd | + |
2470 // | ordered | target parallel | + |
2472 // +------------------+-----------------+------------------------------------+
2473 // | atomic | parallel | |
2474 // | atomic | for | |
2475 // | atomic | for simd | |
2476 // | atomic | master | |
2477 // | atomic | critical | |
2478 // | atomic | simd | |
2479 // | atomic | sections | |
2480 // | atomic | section | |
2481 // | atomic | single | |
2482 // | atomic | parallel for | |
2483 // | atomic |parallel for simd| |
2484 // | atomic |parallel sections| |
2485 // | atomic | task | |
2486 // | atomic | taskyield | |
2487 // | atomic | barrier | |
2488 // | atomic | taskwait | |
2489 // | atomic | taskgroup | |
2490 // | atomic | flush | |
2491 // | atomic | ordered | |
2492 // | atomic | atomic | |
2493 // | atomic | target | |
2494 // | atomic | target parallel | |
2495 // | atomic | target parallel | |
2497 // | atomic | target enter | |
2499 // | atomic | target exit | |
2501 // | atomic | teams | |
2502 // | atomic | cancellation | |
2504 // | atomic | cancel | |
2505 // | atomic | taskloop | |
2506 // | atomic | taskloop simd | |
2507 // | atomic | distribute | |
2508 // | atomic | distribute | |
2509 // | | parallel for | |
2510 // | atomic | distribute | |
2511 // | |parallel for simd| |
2512 // | atomic | distribute simd | |
2513 // | atomic | target parallel | |
2515 // +------------------+-----------------+------------------------------------+
2516 // | target | parallel | * |
2517 // | target | for | * |
2518 // | target | for simd | * |
2519 // | target | master | * |
2520 // | target | critical | * |
2521 // | target | simd | * |
2522 // | target | sections | * |
2523 // | target | section | * |
2524 // | target | single | * |
2525 // | target | parallel for | * |
2526 // | target |parallel for simd| * |
2527 // | target |parallel sections| * |
2528 // | target | task | * |
2529 // | target | taskyield | * |
2530 // | target | barrier | * |
2531 // | target | taskwait | * |
2532 // | target | taskgroup | * |
2533 // | target | flush | * |
2534 // | target | ordered | * |
2535 // | target | atomic | * |
2536 // | target | target | |
2537 // | target | target parallel | |
2538 // | target | target parallel | |
2540 // | target | target enter | |
2542 // | target | target exit | |
2544 // | target | teams | * |
2545 // | target | cancellation | |
2547 // | target | cancel | |
2548 // | target | taskloop | * |
2549 // | target | taskloop simd | * |
2550 // | target | distribute | + |
2551 // | target | distribute | + |
2552 // | | parallel for | |
2553 // | target | distribute | + |
2554 // | |parallel for simd| |
2555 // | target | distribute simd | + |
2556 // | target | target parallel | |
2558 // +------------------+-----------------+------------------------------------+
2559 // | target parallel | parallel | * |
2560 // | target parallel | for | * |
2561 // | target parallel | for simd | * |
2562 // | target parallel | master | * |
2563 // | target parallel | critical | * |
2564 // | target parallel | simd | * |
2565 // | target parallel | sections | * |
2566 // | target parallel | section | * |
2567 // | target parallel | single | * |
2568 // | target parallel | parallel for | * |
2569 // | target parallel |parallel for simd| * |
2570 // | target parallel |parallel sections| * |
2571 // | target parallel | task | * |
2572 // | target parallel | taskyield | * |
2573 // | target parallel | barrier | * |
2574 // | target parallel | taskwait | * |
2575 // | target parallel | taskgroup | * |
2576 // | target parallel | flush | * |
2577 // | target parallel | ordered | * |
2578 // | target parallel | atomic | * |
2579 // | target parallel | target | |
2580 // | target parallel | target parallel | |
2581 // | target parallel | target parallel | |
2583 // | target parallel | target enter | |
2585 // | target parallel | target exit | |
2587 // | target parallel | teams | |
2588 // | target parallel | cancellation | |
2590 // | target parallel | cancel | ! |
2591 // | target parallel | taskloop | * |
2592 // | target parallel | taskloop simd | * |
2593 // | target parallel | distribute | |
2594 // | target parallel | distribute | |
2595 // | | parallel for | |
2596 // | target parallel | distribute | |
2597 // | |parallel for simd| |
2598 // | target parallel | distribute simd | |
2599 // | target parallel | target parallel | |
2601 // +------------------+-----------------+------------------------------------+
2602 // | target parallel | parallel | * |
2604 // | target parallel | for | * |
2606 // | target parallel | for simd | * |
2608 // | target parallel | master | * |
2610 // | target parallel | critical | * |
2612 // | target parallel | simd | * |
2614 // | target parallel | sections | * |
2616 // | target parallel | section | * |
2618 // | target parallel | single | * |
2620 // | target parallel | parallel for | * |
2622 // | target parallel |parallel for simd| * |
2624 // | target parallel |parallel sections| * |
2626 // | target parallel | task | * |
2628 // | target parallel | taskyield | * |
2630 // | target parallel | barrier | * |
2632 // | target parallel | taskwait | * |
2634 // | target parallel | taskgroup | * |
2636 // | target parallel | flush | * |
2638 // | target parallel | ordered | * |
2640 // | target parallel | atomic | * |
2642 // | target parallel | target | |
2644 // | target parallel | target parallel | |
2646 // | target parallel | target parallel | |
2648 // | target parallel | target enter | |
2650 // | target parallel | target exit | |
2652 // | target parallel | teams | |
2654 // | target parallel | cancellation | |
2655 // | for | point | ! |
2656 // | target parallel | cancel | ! |
2658 // | target parallel | taskloop | * |
2660 // | target parallel | taskloop simd | * |
2662 // | target parallel | distribute | |
2664 // | target parallel | distribute | |
2665 // | for | parallel for | |
2666 // | target parallel | distribute | |
2667 // | for |parallel for simd| |
2668 // | target parallel | distribute simd | |
2670 // | target parallel | target parallel | |
2671 // | for | for simd | |
2672 // +------------------+-----------------+------------------------------------+
2673 // | teams | parallel | * |
2674 // | teams | for | + |
2675 // | teams | for simd | + |
2676 // | teams | master | + |
2677 // | teams | critical | + |
2678 // | teams | simd | + |
2679 // | teams | sections | + |
2680 // | teams | section | + |
2681 // | teams | single | + |
2682 // | teams | parallel for | * |
2683 // | teams |parallel for simd| * |
2684 // | teams |parallel sections| * |
2685 // | teams | task | + |
2686 // | teams | taskyield | + |
2687 // | teams | barrier | + |
2688 // | teams | taskwait | + |
2689 // | teams | taskgroup | + |
2690 // | teams | flush | + |
2691 // | teams | ordered | + |
2692 // | teams | atomic | + |
2693 // | teams | target | + |
2694 // | teams | target parallel | + |
2695 // | teams | target parallel | + |
2697 // | teams | target enter | + |
2699 // | teams | target exit | + |
2701 // | teams | teams | + |
2702 // | teams | cancellation | |
2704 // | teams | cancel | |
2705 // | teams | taskloop | + |
2706 // | teams | taskloop simd | + |
2707 // | teams | distribute | ! |
2708 // | teams | distribute | ! |
2709 // | | parallel for | |
2710 // | teams | distribute | ! |
2711 // | |parallel for simd| |
2712 // | teams | distribute simd | ! |
2713 // | teams | target parallel | + |
2715 // +------------------+-----------------+------------------------------------+
2716 // | taskloop | parallel | * |
2717 // | taskloop | for | + |
2718 // | taskloop | for simd | + |
2719 // | taskloop | master | + |
2720 // | taskloop | critical | * |
2721 // | taskloop | simd | * |
2722 // | taskloop | sections | + |
2723 // | taskloop | section | + |
2724 // | taskloop | single | + |
2725 // | taskloop | parallel for | * |
2726 // | taskloop |parallel for simd| * |
2727 // | taskloop |parallel sections| * |
2728 // | taskloop | task | * |
2729 // | taskloop | taskyield | * |
2730 // | taskloop | barrier | + |
2731 // | taskloop | taskwait | * |
2732 // | taskloop | taskgroup | * |
2733 // | taskloop | flush | * |
2734 // | taskloop | ordered | + |
2735 // | taskloop | atomic | * |
2736 // | taskloop | target | * |
2737 // | taskloop | target parallel | * |
2738 // | taskloop | target parallel | * |
2740 // | taskloop | target enter | * |
2742 // | taskloop | target exit | * |
2744 // | taskloop | teams | + |
2745 // | taskloop | cancellation | |
2747 // | taskloop | cancel | |
2748 // | taskloop | taskloop | * |
2749 // | taskloop | distribute | + |
2750 // | taskloop | distribute | + |
2751 // | | parallel for | |
2752 // | taskloop | distribute | + |
2753 // | |parallel for simd| |
2754 // | taskloop | distribute simd | + |
2755 // | taskloop | target parallel | * |
2757 // +------------------+-----------------+------------------------------------+
2758 // | taskloop simd | parallel | |
2759 // | taskloop simd | for | |
2760 // | taskloop simd | for simd | |
2761 // | taskloop simd | master | |
2762 // | taskloop simd | critical | |
2763 // | taskloop simd | simd | * |
2764 // | taskloop simd | sections | |
2765 // | taskloop simd | section | |
2766 // | taskloop simd | single | |
2767 // | taskloop simd | parallel for | |
2768 // | taskloop simd |parallel for simd| |
2769 // | taskloop simd |parallel sections| |
2770 // | taskloop simd | task | |
2771 // | taskloop simd | taskyield | |
2772 // | taskloop simd | barrier | |
2773 // | taskloop simd | taskwait | |
2774 // | taskloop simd | taskgroup | |
2775 // | taskloop simd | flush | |
2776 // | taskloop simd | ordered | + (with simd clause) |
2777 // | taskloop simd | atomic | |
2778 // | taskloop simd | target | |
2779 // | taskloop simd | target parallel | |
2780 // | taskloop simd | target parallel | |
2782 // | taskloop simd | target enter | |
2784 // | taskloop simd | target exit | |
2786 // | taskloop simd | teams | |
2787 // | taskloop simd | cancellation | |
2789 // | taskloop simd | cancel | |
2790 // | taskloop simd | taskloop | |
2791 // | taskloop simd | taskloop simd | |
2792 // | taskloop simd | distribute | |
2793 // | taskloop simd | distribute | |
2794 // | | parallel for | |
2795 // | taskloop simd | distribute | |
2796 // | |parallel for simd| |
2797 // | taskloop simd | distribute simd | |
2798 // | taskloop simd | target parallel | |
2800 // +------------------+-----------------+------------------------------------+
2801 // | distribute | parallel | * |
2802 // | distribute | for | * |
2803 // | distribute | for simd | * |
2804 // | distribute | master | * |
2805 // | distribute | critical | * |
2806 // | distribute | simd | * |
2807 // | distribute | sections | * |
2808 // | distribute | section | * |
2809 // | distribute | single | * |
2810 // | distribute | parallel for | * |
2811 // | distribute |parallel for simd| * |
2812 // | distribute |parallel sections| * |
2813 // | distribute | task | * |
2814 // | distribute | taskyield | * |
2815 // | distribute | barrier | * |
2816 // | distribute | taskwait | * |
2817 // | distribute | taskgroup | * |
2818 // | distribute | flush | * |
2819 // | distribute | ordered | + |
2820 // | distribute | atomic | * |
2821 // | distribute | target | |
2822 // | distribute | target parallel | |
2823 // | distribute | target parallel | |
2825 // | distribute | target enter | |
2827 // | distribute | target exit | |
2829 // | distribute | teams | |
2830 // | distribute | cancellation | + |
2832 // | distribute | cancel | + |
2833 // | distribute | taskloop | * |
2834 // | distribute | taskloop simd | * |
2835 // | distribute | distribute | |
2836 // | distribute | distribute | |
2837 // | | parallel for | |
2838 // | distribute | distribute | |
2839 // | |parallel for simd| |
2840 // | distribute | distribute simd | |
2841 // | distribute | target parallel | |
2843 // +------------------+-----------------+------------------------------------+
2844 // | distribute | parallel | * |
2845 // | parallel for | | |
2846 // | distribute | for | * |
2847 // | parallel for | | |
2848 // | distribute | for simd | * |
2849 // | parallel for | | |
2850 // | distribute | master | * |
2851 // | parallel for | | |
2852 // | distribute | critical | * |
2853 // | parallel for | | |
2854 // | distribute | simd | * |
2855 // | parallel for | | |
2856 // | distribute | sections | * |
2857 // | parallel for | | |
2858 // | distribute | section | * |
2859 // | parallel for | | |
2860 // | distribute | single | * |
2861 // | parallel for | | |
2862 // | distribute | parallel for | * |
2863 // | parallel for | | |
2864 // | distribute |parallel for simd| * |
2865 // | parallel for | | |
2866 // | distribute |parallel sections| * |
2867 // | parallel for | | |
2868 // | distribute | task | * |
2869 // | parallel for | | |
2870 // | parallel for | | |
2871 // | distribute | taskyield | * |
2872 // | parallel for | | |
2873 // | distribute | barrier | * |
2874 // | parallel for | | |
2875 // | distribute | taskwait | * |
2876 // | parallel for | | |
2877 // | distribute | taskgroup | * |
2878 // | parallel for | | |
2879 // | distribute | flush | * |
2880 // | parallel for | | |
2881 // | distribute | ordered | + |
2882 // | parallel for | | |
2883 // | distribute | atomic | * |
2884 // | parallel for | | |
2885 // | distribute | target | |
2886 // | parallel for | | |
2887 // | distribute | target parallel | |
2888 // | parallel for | | |
2889 // | distribute | target parallel | |
2890 // | parallel for | for | |
2891 // | distribute | target enter | |
2892 // | parallel for | data | |
2893 // | distribute | target exit | |
2894 // | parallel for | data | |
2895 // | distribute | teams | |
2896 // | parallel for | | |
2897 // | distribute | cancellation | + |
2898 // | parallel for | point | |
2899 // | distribute | cancel | + |
2900 // | parallel for | | |
2901 // | distribute | taskloop | * |
2902 // | parallel for | | |
2903 // | distribute | taskloop simd | * |
2904 // | parallel for | | |
2905 // | distribute | distribute | |
2906 // | parallel for | | |
2907 // | distribute | distribute | |
2908 // | parallel for | parallel for | |
2909 // | distribute | distribute | |
2910 // | parallel for |parallel for simd| |
2911 // | distribute | distribute simd | |
2912 // | parallel for | | |
2913 // | distribute | target parallel | |
2914 // | parallel for | for simd | |
2915 // +------------------+-----------------+------------------------------------+
2916 // | distribute | parallel | * |
2917 // | parallel for simd| | |
2918 // | distribute | for | * |
2919 // | parallel for simd| | |
2920 // | distribute | for simd | * |
2921 // | parallel for simd| | |
2922 // | distribute | master | * |
2923 // | parallel for simd| | |
2924 // | distribute | critical | * |
2925 // | parallel for simd| | |
2926 // | distribute | simd | * |
2927 // | parallel for simd| | |
2928 // | distribute | sections | * |
2929 // | parallel for simd| | |
2930 // | distribute | section | * |
2931 // | parallel for simd| | |
2932 // | distribute | single | * |
2933 // | parallel for simd| | |
2934 // | distribute | parallel for | * |
2935 // | parallel for simd| | |
2936 // | distribute |parallel for simd| * |
2937 // | parallel for simd| | |
2938 // | distribute |parallel sections| * |
2939 // | parallel for simd| | |
2940 // | distribute | task | * |
2941 // | parallel for simd| | |
2942 // | distribute | taskyield | * |
2943 // | parallel for simd| | |
2944 // | distribute | barrier | * |
2945 // | parallel for simd| | |
2946 // | distribute | taskwait | * |
2947 // | parallel for simd| | |
2948 // | distribute | taskgroup | * |
2949 // | parallel for simd| | |
2950 // | distribute | flush | * |
2951 // | parallel for simd| | |
2952 // | distribute | ordered | + |
2953 // | parallel for simd| | |
2954 // | distribute | atomic | * |
2955 // | parallel for simd| | |
2956 // | distribute | target | |
2957 // | parallel for simd| | |
2958 // | distribute | target parallel | |
2959 // | parallel for simd| | |
2960 // | distribute | target parallel | |
2961 // | parallel for simd| for | |
2962 // | distribute | target enter | |
2963 // | parallel for simd| data | |
2964 // | distribute | target exit | |
2965 // | parallel for simd| data | |
2966 // | distribute | teams | |
2967 // | parallel for simd| | |
2968 // | distribute | cancellation | + |
2969 // | parallel for simd| point | |
2970 // | distribute | cancel | + |
2971 // | parallel for simd| | |
2972 // | distribute | taskloop | * |
2973 // | parallel for simd| | |
2974 // | distribute | taskloop simd | * |
2975 // | parallel for simd| | |
2976 // | distribute | distribute | |
2977 // | parallel for simd| | |
2978 // | distribute | distribute | * |
2979 // | parallel for simd| parallel for | |
2980 // | distribute | distribute | * |
2981 // | parallel for simd|parallel for simd| |
2982 // | distribute | distribute simd | * |
2983 // | parallel for simd| | |
2984 // | distribute | target parallel | |
2985 // | parallel for simd| for simd | |
2986 // +------------------+-----------------+------------------------------------+
2987 // | distribute simd | parallel | * |
2988 // | distribute simd | for | * |
2989 // | distribute simd | for simd | * |
2990 // | distribute simd | master | * |
2991 // | distribute simd | critical | * |
2992 // | distribute simd | simd | * |
2993 // | distribute simd | sections | * |
2994 // | distribute simd | section | * |
2995 // | distribute simd | single | * |
2996 // | distribute simd | parallel for | * |
2997 // | distribute simd |parallel for simd| * |
2998 // | distribute simd |parallel sections| * |
2999 // | distribute simd | task | * |
3000 // | distribute simd | taskyield | * |
3001 // | distribute simd | barrier | * |
3002 // | distribute simd | taskwait | * |
3003 // | distribute simd | taskgroup | * |
3004 // | distribute simd | flush | * |
3005 // | distribute simd | ordered | + |
3006 // | distribute simd | atomic | * |
3007 // | distribute simd | target | * |
3008 // | distribute simd | target parallel | * |
3009 // | distribute simd | target parallel | * |
3011 // | distribute simd | target enter | * |
3013 // | distribute simd | target exit | * |
3015 // | distribute simd | teams | * |
3016 // | distribute simd | cancellation | + |
3018 // | distribute simd | cancel | + |
3019 // | distribute simd | taskloop | * |
3020 // | distribute simd | taskloop simd | * |
3021 // | distribute simd | distribute | |
3022 // | distribute simd | distribute | * |
3023 // | | parallel for | |
3024 // | distribute simd | distribute | * |
3025 // | |parallel for simd| |
3026 // | distribute simd | distribute simd | * |
3027 // | distribute simd | target parallel | * |
3029 // +------------------+-----------------+------------------------------------+
3030 // | target parallel | parallel | * |
3032 // | target parallel | for | * |
3034 // | target parallel | for simd | * |
3036 // | target parallel | master | * |
3038 // | target parallel | critical | * |
3040 // | target parallel | simd | ! |
3042 // | target parallel | sections | * |
3044 // | target parallel | section | * |
3046 // | target parallel | single | * |
3048 // | target parallel | parallel for | * |
3050 // | target parallel |parallel for simd| * |
3052 // | target parallel |parallel sections| * |
3054 // | target parallel | task | * |
3056 // | target parallel | taskyield | * |
3058 // | target parallel | barrier | * |
3060 // | target parallel | taskwait | * |
3062 // | target parallel | taskgroup | * |
3064 // | target parallel | flush | * |
3066 // | target parallel | ordered | + (with simd clause) |
3068 // | target parallel | atomic | * |
3070 // | target parallel | target | * |
3072 // | target parallel | target parallel | * |
3074 // | target parallel | target parallel | * |
3075 // | for simd | for | |
3076 // | target parallel | target enter | * |
3077 // | for simd | data | |
3078 // | target parallel | target exit | * |
3079 // | for simd | data | |
3080 // | target parallel | teams | * |
3082 // | target parallel | cancellation | * |
3083 // | for simd | point | |
3084 // | target parallel | cancel | * |
3086 // | target parallel | taskloop | * |
3088 // | target parallel | taskloop simd | * |
3090 // | target parallel | distribute | * |
3092 // | target parallel | distribute | * |
3093 // | for simd | parallel for | |
3094 // | target parallel | distribute | * |
3095 // | for simd |parallel for simd| |
3096 // | target parallel | distribute simd | * |
3098 // | target parallel | target parallel | * |
3099 // | for simd | for simd | |
3100 // +------------------+-----------------+------------------------------------+
3101 if (Stack->getCurScope()) {
3102 auto ParentRegion = Stack->getParentDirective();
3103 auto OffendingRegion = ParentRegion;
3104 bool NestingProhibited = false;
3105 bool CloseNesting = true;
3108 ShouldBeInParallelRegion,
3109 ShouldBeInOrderedRegion,
3110 ShouldBeInTargetRegion,
3111 ShouldBeInTeamsRegion
3112 } Recommend = NoRecommend;
3113 if (isOpenMPSimdDirective(ParentRegion) && CurrentRegion != OMPD_ordered) {
3114 // OpenMP [2.16, Nesting of Regions]
3115 // OpenMP constructs may not be nested inside a simd region.
3116 // OpenMP [2.8.1,simd Construct, Restrictions]
3117 // An ordered construct with the simd clause is the only OpenMP
3118 // construct that can appear in the simd region.
3119 // Allowing a SIMD consruct nested in another SIMD construct is an
3120 // extension. The OpenMP 4.5 spec does not allow it. Issue a warning
3122 SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd)
3123 ? diag::err_omp_prohibited_region_simd
3124 : diag::warn_omp_nesting_simd);
3125 return CurrentRegion != OMPD_simd;
3127 if (ParentRegion == OMPD_atomic) {
3128 // OpenMP [2.16, Nesting of Regions]
3129 // OpenMP constructs may not be nested inside an atomic region.
3130 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic);
3133 if (CurrentRegion == OMPD_section) {
3134 // OpenMP [2.7.2, sections Construct, Restrictions]
3135 // Orphaned section directives are prohibited. That is, the section
3136 // directives must appear within the sections construct and must not be
3137 // encountered elsewhere in the sections region.
3138 if (ParentRegion != OMPD_sections &&
3139 ParentRegion != OMPD_parallel_sections) {
3140 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
3141 << (ParentRegion != OMPD_unknown)
3142 << getOpenMPDirectiveName(ParentRegion);
3147 // Allow some constructs to be orphaned (they could be used in functions,
3148 // called from OpenMP regions with the required preconditions).
3149 if (ParentRegion == OMPD_unknown)
3151 if (CurrentRegion == OMPD_cancellation_point ||
3152 CurrentRegion == OMPD_cancel) {
3153 // OpenMP [2.16, Nesting of Regions]
3154 // A cancellation point construct for which construct-type-clause is
3155 // taskgroup must be nested inside a task construct. A cancellation
3156 // point construct for which construct-type-clause is not taskgroup must
3157 // be closely nested inside an OpenMP construct that matches the type
3158 // specified in construct-type-clause.
3159 // A cancel construct for which construct-type-clause is taskgroup must be
3160 // nested inside a task construct. A cancel construct for which
3161 // construct-type-clause is not taskgroup must be closely nested inside an
3162 // OpenMP construct that matches the type specified in
3163 // construct-type-clause.
3165 !((CancelRegion == OMPD_parallel &&
3166 (ParentRegion == OMPD_parallel ||
3167 ParentRegion == OMPD_target_parallel)) ||
3168 (CancelRegion == OMPD_for &&
3169 (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for ||
3170 ParentRegion == OMPD_target_parallel_for)) ||
3171 (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) ||
3172 (CancelRegion == OMPD_sections &&
3173 (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
3174 ParentRegion == OMPD_parallel_sections)));
3175 } else if (CurrentRegion == OMPD_master) {
3176 // OpenMP [2.16, Nesting of Regions]
3177 // A master region may not be closely nested inside a worksharing,
3178 // atomic, or explicit task region.
3179 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
3180 isOpenMPTaskingDirective(ParentRegion);
3181 } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
3182 // OpenMP [2.16, Nesting of Regions]
3183 // A critical region may not be nested (closely or otherwise) inside a
3184 // critical region with the same name. Note that this restriction is not
3185 // sufficient to prevent deadlock.
3186 SourceLocation PreviousCriticalLoc;
3188 Stack->hasDirective([CurrentName, &PreviousCriticalLoc](
3189 OpenMPDirectiveKind K,
3190 const DeclarationNameInfo &DNI,
3193 if (K == OMPD_critical &&
3194 DNI.getName() == CurrentName.getName()) {
3195 PreviousCriticalLoc = Loc;
3200 false /* skip top directive */);
3202 SemaRef.Diag(StartLoc,
3203 diag::err_omp_prohibited_region_critical_same_name)
3204 << CurrentName.getName();
3205 if (PreviousCriticalLoc.isValid())
3206 SemaRef.Diag(PreviousCriticalLoc,
3207 diag::note_omp_previous_critical_region);
3210 } else if (CurrentRegion == OMPD_barrier) {
3211 // OpenMP [2.16, Nesting of Regions]
3212 // A barrier region may not be closely nested inside a worksharing,
3213 // explicit task, critical, ordered, atomic, or master region.
3214 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
3215 isOpenMPTaskingDirective(ParentRegion) ||
3216 ParentRegion == OMPD_master ||
3217 ParentRegion == OMPD_critical ||
3218 ParentRegion == OMPD_ordered;
3219 } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
3220 !isOpenMPParallelDirective(CurrentRegion)) {
3221 // OpenMP [2.16, Nesting of Regions]
3222 // A worksharing region may not be closely nested inside a worksharing,
3223 // explicit task, critical, ordered, atomic, or master region.
3224 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
3225 isOpenMPTaskingDirective(ParentRegion) ||
3226 ParentRegion == OMPD_master ||
3227 ParentRegion == OMPD_critical ||
3228 ParentRegion == OMPD_ordered;
3229 Recommend = ShouldBeInParallelRegion;
3230 } else if (CurrentRegion == OMPD_ordered) {
3231 // OpenMP [2.16, Nesting of Regions]
3232 // An ordered region may not be closely nested inside a critical,
3233 // atomic, or explicit task region.
3234 // An ordered region must be closely nested inside a loop region (or
3235 // parallel loop region) with an ordered clause.
3236 // OpenMP [2.8.1,simd Construct, Restrictions]
3237 // An ordered construct with the simd clause is the only OpenMP construct
3238 // that can appear in the simd region.
3239 NestingProhibited = ParentRegion == OMPD_critical ||
3240 isOpenMPTaskingDirective(ParentRegion) ||
3241 !(isOpenMPSimdDirective(ParentRegion) ||
3242 Stack->isParentOrderedRegion());
3243 Recommend = ShouldBeInOrderedRegion;
3244 } else if (isOpenMPTeamsDirective(CurrentRegion)) {
3245 // OpenMP [2.16, Nesting of Regions]
3246 // If specified, a teams construct must be contained within a target
3248 NestingProhibited = ParentRegion != OMPD_target;
3249 Recommend = ShouldBeInTargetRegion;
3250 Stack->setParentTeamsRegionLoc(Stack->getConstructLoc());
3252 if (!NestingProhibited && isOpenMPTeamsDirective(ParentRegion)) {
3253 // OpenMP [2.16, Nesting of Regions]
3254 // distribute, parallel, parallel sections, parallel workshare, and the
3255 // parallel loop and parallel loop SIMD constructs are the only OpenMP
3256 // constructs that can be closely nested in the teams region.
3257 NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) &&
3258 !isOpenMPDistributeDirective(CurrentRegion);
3259 Recommend = ShouldBeInParallelRegion;
3261 if (!NestingProhibited && isOpenMPDistributeDirective(CurrentRegion)) {
3262 // OpenMP 4.5 [2.17 Nesting of Regions]
3263 // The region associated with the distribute construct must be strictly
3264 // nested inside a teams region
3265 NestingProhibited = !isOpenMPTeamsDirective(ParentRegion);
3266 Recommend = ShouldBeInTeamsRegion;
3268 if (!NestingProhibited &&
3269 (isOpenMPTargetExecutionDirective(CurrentRegion) ||
3270 isOpenMPTargetDataManagementDirective(CurrentRegion))) {
3271 // OpenMP 4.5 [2.17 Nesting of Regions]
3272 // If a target, target update, target data, target enter data, or
3273 // target exit data construct is encountered during execution of a
3274 // target region, the behavior is unspecified.
3275 NestingProhibited = Stack->hasDirective(
3276 [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &,
3277 SourceLocation) -> bool {
3278 if (isOpenMPTargetExecutionDirective(K)) {
3279 OffendingRegion = K;
3284 false /* don't skip top directive */);
3285 CloseNesting = false;
3287 if (NestingProhibited) {
3288 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region)
3289 << CloseNesting << getOpenMPDirectiveName(OffendingRegion)
3290 << Recommend << getOpenMPDirectiveName(CurrentRegion);
3297 static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
3298 ArrayRef<OMPClause *> Clauses,
3299 ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
3300 bool ErrorFound = false;
3301 unsigned NamedModifiersNumber = 0;
3302 SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers(
3304 SmallVector<SourceLocation, 4> NameModifierLoc;
3305 for (const auto *C : Clauses) {
3306 if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {
3307 // At most one if clause without a directive-name-modifier can appear on
3309 OpenMPDirectiveKind CurNM = IC->getNameModifier();
3310 if (FoundNameModifiers[CurNM]) {
3311 S.Diag(C->getLocStart(), diag::err_omp_more_one_clause)
3312 << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if)
3313 << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM);
3315 } else if (CurNM != OMPD_unknown) {
3316 NameModifierLoc.push_back(IC->getNameModifierLoc());
3317 ++NamedModifiersNumber;
3319 FoundNameModifiers[CurNM] = IC;
3320 if (CurNM == OMPD_unknown)
3322 // Check if the specified name modifier is allowed for the current
3324 // At most one if clause with the particular directive-name-modifier can
3325 // appear on the directive.
3326 bool MatchFound = false;
3327 for (auto NM : AllowedNameModifiers) {
3334 S.Diag(IC->getNameModifierLoc(),
3335 diag::err_omp_wrong_if_directive_name_modifier)
3336 << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind);
3341 // If any if clause on the directive includes a directive-name-modifier then
3342 // all if clauses on the directive must include a directive-name-modifier.
3343 if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {
3344 if (NamedModifiersNumber == AllowedNameModifiers.size()) {
3345 S.Diag(FoundNameModifiers[OMPD_unknown]->getLocStart(),
3346 diag::err_omp_no_more_if_clause);
3349 std::string Sep(", ");
3350 unsigned AllowedCnt = 0;
3351 unsigned TotalAllowedNum =
3352 AllowedNameModifiers.size() - NamedModifiersNumber;
3353 for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End;
3355 OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt];
3356 if (!FoundNameModifiers[NM]) {
3358 Values += getOpenMPDirectiveName(NM);
3360 if (AllowedCnt + 2 == TotalAllowedNum)
3362 else if (AllowedCnt + 1 != TotalAllowedNum)
3367 S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getLocStart(),
3368 diag::err_omp_unnamed_if_clause)
3369 << (TotalAllowedNum > 1) << Values;
3371 for (auto Loc : NameModifierLoc) {
3372 S.Diag(Loc, diag::note_omp_previous_named_if_clause);
3379 StmtResult Sema::ActOnOpenMPExecutableDirective(
3380 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
3381 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
3382 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
3383 StmtResult Res = StmtError();
3384 if (CheckNestingOfRegions(*this, DSAStack, Kind, DirName, CancelRegion,
3388 llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
3389 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
3390 bool ErrorFound = false;
3391 ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
3393 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
3395 // Check default data sharing attributes for referenced variables.
3396 DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt));
3397 DSAChecker.Visit(cast<CapturedStmt>(AStmt)->getCapturedStmt());
3398 if (DSAChecker.isErrorFound())
3400 // Generate list of implicitly defined firstprivate variables.
3401 VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA();
3403 if (!DSAChecker.getImplicitFirstprivate().empty()) {
3404 if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause(
3405 DSAChecker.getImplicitFirstprivate(), SourceLocation(),
3406 SourceLocation(), SourceLocation())) {
3407 ClausesWithImplicit.push_back(Implicit);
3408 ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() !=
3409 DSAChecker.getImplicitFirstprivate().size();
3415 llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
3418 Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
3420 AllowedNameModifiers.push_back(OMPD_parallel);
3423 Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
3424 VarsWithInheritedDSA);
3427 Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
3428 VarsWithInheritedDSA);
3431 Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
3432 EndLoc, VarsWithInheritedDSA);
3435 Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
3439 assert(ClausesWithImplicit.empty() &&
3440 "No clauses are allowed for 'omp section' directive");
3441 Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
3444 Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
3448 assert(ClausesWithImplicit.empty() &&
3449 "No clauses are allowed for 'omp master' directive");
3450 Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
3453 Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt,
3456 case OMPD_parallel_for:
3457 Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc,
3458 EndLoc, VarsWithInheritedDSA);
3459 AllowedNameModifiers.push_back(OMPD_parallel);
3461 case OMPD_parallel_for_simd:
3462 Res = ActOnOpenMPParallelForSimdDirective(
3463 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3464 AllowedNameModifiers.push_back(OMPD_parallel);
3466 case OMPD_parallel_sections:
3467 Res = ActOnOpenMPParallelSectionsDirective(ClausesWithImplicit, AStmt,
3469 AllowedNameModifiers.push_back(OMPD_parallel);
3473 ActOnOpenMPTaskDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
3474 AllowedNameModifiers.push_back(OMPD_task);
3476 case OMPD_taskyield:
3477 assert(ClausesWithImplicit.empty() &&
3478 "No clauses are allowed for 'omp taskyield' directive");
3479 assert(AStmt == nullptr &&
3480 "No associated statement allowed for 'omp taskyield' directive");
3481 Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc);
3484 assert(ClausesWithImplicit.empty() &&
3485 "No clauses are allowed for 'omp barrier' directive");
3486 assert(AStmt == nullptr &&
3487 "No associated statement allowed for 'omp barrier' directive");
3488 Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
3491 assert(ClausesWithImplicit.empty() &&
3492 "No clauses are allowed for 'omp taskwait' directive");
3493 assert(AStmt == nullptr &&
3494 "No associated statement allowed for 'omp taskwait' directive");
3495 Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc);
3497 case OMPD_taskgroup:
3498 assert(ClausesWithImplicit.empty() &&
3499 "No clauses are allowed for 'omp taskgroup' directive");
3500 Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc);
3503 assert(AStmt == nullptr &&
3504 "No associated statement allowed for 'omp flush' directive");
3505 Res = ActOnOpenMPFlushDirective(ClausesWithImplicit, StartLoc, EndLoc);
3508 Res = ActOnOpenMPOrderedDirective(ClausesWithImplicit, AStmt, StartLoc,
3512 Res = ActOnOpenMPAtomicDirective(ClausesWithImplicit, AStmt, StartLoc,
3517 ActOnOpenMPTeamsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
3520 Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc,
3522 AllowedNameModifiers.push_back(OMPD_target);
3524 case OMPD_target_parallel:
3525 Res = ActOnOpenMPTargetParallelDirective(ClausesWithImplicit, AStmt,
3527 AllowedNameModifiers.push_back(OMPD_target);
3528 AllowedNameModifiers.push_back(OMPD_parallel);
3530 case OMPD_target_parallel_for:
3531 Res = ActOnOpenMPTargetParallelForDirective(
3532 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3533 AllowedNameModifiers.push_back(OMPD_target);
3534 AllowedNameModifiers.push_back(OMPD_parallel);
3536 case OMPD_cancellation_point:
3537 assert(ClausesWithImplicit.empty() &&
3538 "No clauses are allowed for 'omp cancellation point' directive");
3539 assert(AStmt == nullptr && "No associated statement allowed for 'omp "
3540 "cancellation point' directive");
3541 Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion);
3544 assert(AStmt == nullptr &&
3545 "No associated statement allowed for 'omp cancel' directive");
3546 Res = ActOnOpenMPCancelDirective(ClausesWithImplicit, StartLoc, EndLoc,
3548 AllowedNameModifiers.push_back(OMPD_cancel);
3550 case OMPD_target_data:
3551 Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc,
3553 AllowedNameModifiers.push_back(OMPD_target_data);
3555 case OMPD_target_enter_data:
3556 Res = ActOnOpenMPTargetEnterDataDirective(ClausesWithImplicit, StartLoc,
3558 AllowedNameModifiers.push_back(OMPD_target_enter_data);
3560 case OMPD_target_exit_data:
3561 Res = ActOnOpenMPTargetExitDataDirective(ClausesWithImplicit, StartLoc,
3563 AllowedNameModifiers.push_back(OMPD_target_exit_data);
3566 Res = ActOnOpenMPTaskLoopDirective(ClausesWithImplicit, AStmt, StartLoc,
3567 EndLoc, VarsWithInheritedDSA);
3568 AllowedNameModifiers.push_back(OMPD_taskloop);
3570 case OMPD_taskloop_simd:
3571 Res = ActOnOpenMPTaskLoopSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
3572 EndLoc, VarsWithInheritedDSA);
3573 AllowedNameModifiers.push_back(OMPD_taskloop);
3575 case OMPD_distribute:
3576 Res = ActOnOpenMPDistributeDirective(ClausesWithImplicit, AStmt, StartLoc,
3577 EndLoc, VarsWithInheritedDSA);
3579 case OMPD_target_update:
3580 assert(!AStmt && "Statement is not allowed for target update");
3582 ActOnOpenMPTargetUpdateDirective(ClausesWithImplicit, StartLoc, EndLoc);
3583 AllowedNameModifiers.push_back(OMPD_target_update);
3585 case OMPD_distribute_parallel_for:
3586 Res = ActOnOpenMPDistributeParallelForDirective(
3587 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3588 AllowedNameModifiers.push_back(OMPD_parallel);
3590 case OMPD_distribute_parallel_for_simd:
3591 Res = ActOnOpenMPDistributeParallelForSimdDirective(
3592 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3593 AllowedNameModifiers.push_back(OMPD_parallel);
3595 case OMPD_distribute_simd:
3596 Res = ActOnOpenMPDistributeSimdDirective(
3597 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3599 case OMPD_target_parallel_for_simd:
3600 Res = ActOnOpenMPTargetParallelForSimdDirective(
3601 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
3602 AllowedNameModifiers.push_back(OMPD_target);
3603 AllowedNameModifiers.push_back(OMPD_parallel);
3605 case OMPD_declare_target:
3606 case OMPD_end_declare_target:
3607 case OMPD_threadprivate:
3608 case OMPD_declare_reduction:
3609 case OMPD_declare_simd:
3610 llvm_unreachable("OpenMP Directive is not allowed");
3612 llvm_unreachable("Unknown OpenMP directive");
3615 for (auto P : VarsWithInheritedDSA) {
3616 Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
3617 << P.first << P.second->getSourceRange();
3619 ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound;
3621 if (!AllowedNameModifiers.empty())
3622 ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) ||
3630 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
3631 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
3632 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
3633 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
3634 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
3635 assert(Aligneds.size() == Alignments.size());
3636 assert(Linears.size() == LinModifiers.size());
3637 assert(Linears.size() == Steps.size());
3638 if (!DG || DG.get().isNull())
3639 return DeclGroupPtrTy();
3641 if (!DG.get().isSingleDecl()) {
3642 Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd);
3645 auto *ADecl = DG.get().getSingleDecl();
3646 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
3647 ADecl = FTD->getTemplatedDecl();
3649 auto *FD = dyn_cast<FunctionDecl>(ADecl);
3651 Diag(ADecl->getLocation(), diag::err_omp_function_expected);
3652 return DeclGroupPtrTy();
3655 // OpenMP [2.8.2, declare simd construct, Description]
3656 // The parameter of the simdlen clause must be a constant positive integer
3660 SL = VerifyPositiveIntegerConstantInClause(Simdlen, OMPC_simdlen);
3661 // OpenMP [2.8.2, declare simd construct, Description]
3662 // The special this pointer can be used as if was one of the arguments to the
3663 // function in any of the linear, aligned, or uniform clauses.
3664 // The uniform clause declares one or more arguments to have an invariant
3665 // value for all concurrent invocations of the function in the execution of a
3666 // single SIMD loop.
3667 llvm::DenseMap<Decl *, Expr *> UniformedArgs;
3668 Expr *UniformedLinearThis = nullptr;
3669 for (auto *E : Uniforms) {
3670 E = E->IgnoreParenImpCasts();
3671 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
3672 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
3673 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
3674 FD->getParamDecl(PVD->getFunctionScopeIndex())
3675 ->getCanonicalDecl() == PVD->getCanonicalDecl()) {
3676 UniformedArgs.insert(std::make_pair(PVD->getCanonicalDecl(), E));
3679 if (isa<CXXThisExpr>(E)) {
3680 UniformedLinearThis = E;
3683 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
3684 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
3686 // OpenMP [2.8.2, declare simd construct, Description]
3687 // The aligned clause declares that the object to which each list item points
3688 // is aligned to the number of bytes expressed in the optional parameter of
3689 // the aligned clause.
3690 // The special this pointer can be used as if was one of the arguments to the
3691 // function in any of the linear, aligned, or uniform clauses.
3692 // The type of list items appearing in the aligned clause must be array,
3693 // pointer, reference to array, or reference to pointer.
3694 llvm::DenseMap<Decl *, Expr *> AlignedArgs;
3695 Expr *AlignedThis = nullptr;
3696 for (auto *E : Aligneds) {
3697 E = E->IgnoreParenImpCasts();
3698 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
3699 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
3700 auto *CanonPVD = PVD->getCanonicalDecl();
3701 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
3702 FD->getParamDecl(PVD->getFunctionScopeIndex())
3703 ->getCanonicalDecl() == CanonPVD) {
3704 // OpenMP [2.8.1, simd construct, Restrictions]
3705 // A list-item cannot appear in more than one aligned clause.
3706 if (AlignedArgs.count(CanonPVD) > 0) {
3707 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
3708 << 1 << E->getSourceRange();
3709 Diag(AlignedArgs[CanonPVD]->getExprLoc(),
3710 diag::note_omp_explicit_dsa)
3711 << getOpenMPClauseName(OMPC_aligned);
3714 AlignedArgs[CanonPVD] = E;
3715 QualType QTy = PVD->getType()
3716 .getNonReferenceType()
3717 .getUnqualifiedType()
3718 .getCanonicalType();
3719 const Type *Ty = QTy.getTypePtrOrNull();
3720 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
3721 Diag(E->getExprLoc(), diag::err_omp_aligned_expected_array_or_ptr)
3722 << QTy << getLangOpts().CPlusPlus << E->getSourceRange();
3723 Diag(PVD->getLocation(), diag::note_previous_decl) << PVD;
3728 if (isa<CXXThisExpr>(E)) {
3730 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
3731 << 2 << E->getSourceRange();
3732 Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa)
3733 << getOpenMPClauseName(OMPC_aligned);
3738 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
3739 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
3741 // The optional parameter of the aligned clause, alignment, must be a constant
3742 // positive integer expression. If no optional parameter is specified,
3743 // implementation-defined default alignments for SIMD instructions on the
3744 // target platforms are assumed.
3745 SmallVector<Expr *, 4> NewAligns;
3746 for (auto *E : Alignments) {
3749 Align = VerifyPositiveIntegerConstantInClause(E, OMPC_aligned);
3750 NewAligns.push_back(Align.get());
3752 // OpenMP [2.8.2, declare simd construct, Description]
3753 // The linear clause declares one or more list items to be private to a SIMD
3754 // lane and to have a linear relationship with respect to the iteration space
3756 // The special this pointer can be used as if was one of the arguments to the
3757 // function in any of the linear, aligned, or uniform clauses.
3758 // When a linear-step expression is specified in a linear clause it must be
3759 // either a constant integer expression or an integer-typed parameter that is
3760 // specified in a uniform clause on the directive.
3761 llvm::DenseMap<Decl *, Expr *> LinearArgs;
3762 const bool IsUniformedThis = UniformedLinearThis != nullptr;
3763 auto MI = LinModifiers.begin();
3764 for (auto *E : Linears) {
3765 auto LinKind = static_cast<OpenMPLinearClauseKind>(*MI);
3767 E = E->IgnoreParenImpCasts();
3768 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
3769 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
3770 auto *CanonPVD = PVD->getCanonicalDecl();
3771 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
3772 FD->getParamDecl(PVD->getFunctionScopeIndex())
3773 ->getCanonicalDecl() == CanonPVD) {
3774 // OpenMP [2.15.3.7, linear Clause, Restrictions]
3775 // A list-item cannot appear in more than one linear clause.
3776 if (LinearArgs.count(CanonPVD) > 0) {
3777 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
3778 << getOpenMPClauseName(OMPC_linear)
3779 << getOpenMPClauseName(OMPC_linear) << E->getSourceRange();
3780 Diag(LinearArgs[CanonPVD]->getExprLoc(),
3781 diag::note_omp_explicit_dsa)
3782 << getOpenMPClauseName(OMPC_linear);
3785 // Each argument can appear in at most one uniform or linear clause.
3786 if (UniformedArgs.count(CanonPVD) > 0) {
3787 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
3788 << getOpenMPClauseName(OMPC_linear)
3789 << getOpenMPClauseName(OMPC_uniform) << E->getSourceRange();
3790 Diag(UniformedArgs[CanonPVD]->getExprLoc(),
3791 diag::note_omp_explicit_dsa)
3792 << getOpenMPClauseName(OMPC_uniform);
3795 LinearArgs[CanonPVD] = E;
3796 if (E->isValueDependent() || E->isTypeDependent() ||
3797 E->isInstantiationDependent() ||
3798 E->containsUnexpandedParameterPack())
3800 (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind,
3801 PVD->getOriginalType());
3805 if (isa<CXXThisExpr>(E)) {
3806 if (UniformedLinearThis) {
3807 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
3808 << getOpenMPClauseName(OMPC_linear)
3809 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear)
3810 << E->getSourceRange();
3811 Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa)
3812 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform
3816 UniformedLinearThis = E;
3817 if (E->isValueDependent() || E->isTypeDependent() ||
3818 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
3820 (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind,
3824 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
3825 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
3827 Expr *Step = nullptr;
3828 Expr *NewStep = nullptr;
3829 SmallVector<Expr *, 4> NewSteps;
3830 for (auto *E : Steps) {
3831 // Skip the same step expression, it was checked already.
3832 if (Step == E || !E) {
3833 NewSteps.push_back(E ? NewStep : nullptr);
3837 if (auto *DRE = dyn_cast<DeclRefExpr>(Step))
3838 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
3839 auto *CanonPVD = PVD->getCanonicalDecl();
3840 if (UniformedArgs.count(CanonPVD) == 0) {
3841 Diag(Step->getExprLoc(), diag::err_omp_expected_uniform_param)
3842 << Step->getSourceRange();
3843 } else if (E->isValueDependent() || E->isTypeDependent() ||
3844 E->isInstantiationDependent() ||
3845 E->containsUnexpandedParameterPack() ||
3846 CanonPVD->getType()->hasIntegerRepresentation())
3847 NewSteps.push_back(Step);
3849 Diag(Step->getExprLoc(), diag::err_omp_expected_int_param)
3850 << Step->getSourceRange();
3855 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
3856 !Step->isInstantiationDependent() &&
3857 !Step->containsUnexpandedParameterPack()) {
3858 NewStep = PerformOpenMPImplicitIntegerConversion(Step->getExprLoc(), Step)
3861 NewStep = VerifyIntegerConstantExpression(NewStep).get();
3863 NewSteps.push_back(NewStep);
3865 auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
3866 Context, BS, SL.get(), const_cast<Expr **>(Uniforms.data()),
3867 Uniforms.size(), const_cast<Expr **>(Aligneds.data()), Aligneds.size(),
3868 const_cast<Expr **>(NewAligns.data()), NewAligns.size(),
3869 const_cast<Expr **>(Linears.data()), Linears.size(),
3870 const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(),
3871 NewSteps.data(), NewSteps.size(), SR);
3872 ADecl->addAttr(NewAttr);
3873 return ConvertDeclToDeclGroup(ADecl);
3876 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
3878 SourceLocation StartLoc,
3879 SourceLocation EndLoc) {
3883 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
3884 // 1.2.2 OpenMP Language Terminology
3885 // Structured block - An executable statement with a single entry at the
3886 // top and a single exit at the bottom.
3887 // The point of exit cannot be a branch out of the structured block.
3888 // longjmp() and throw() must not violate the entry/exit criteria.
3889 CS->getCapturedDecl()->setNothrow();
3891 getCurFunction()->setHasBranchProtectedScope();
3893 return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
3894 DSAStack->isCancelRegion());
3898 /// \brief Helper class for checking canonical form of the OpenMP loops and
3899 /// extracting iteration space of each loop in the loop nest, that will be used
3900 /// for IR generation.
3901 class OpenMPIterationSpaceChecker {
3902 /// \brief Reference to Sema.
3904 /// \brief A location for diagnostics (when there is no some better location).
3905 SourceLocation DefaultLoc;
3906 /// \brief A location for diagnostics (when increment is not compatible).
3907 SourceLocation ConditionLoc;
3908 /// \brief A source location for referring to loop init later.
3909 SourceRange InitSrcRange;
3910 /// \brief A source location for referring to condition later.
3911 SourceRange ConditionSrcRange;
3912 /// \brief A source location for referring to increment later.
3913 SourceRange IncrementSrcRange;
3914 /// \brief Loop variable.
3915 ValueDecl *LCDecl = nullptr;
3916 /// \brief Reference to loop variable.
3917 Expr *LCRef = nullptr;
3918 /// \brief Lower bound (initializer for the var).
3920 /// \brief Upper bound.
3922 /// \brief Loop step (increment).
3923 Expr *Step = nullptr;
3924 /// \brief This flag is true when condition is one of:
3929 bool TestIsLessOp = false;
3930 /// \brief This flag is true when condition is strict ( < or > ).
3931 bool TestIsStrictOp = false;
3932 /// \brief This flag is true when step is subtracted on each iteration.
3933 bool SubtractStep = false;
3936 OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc)
3937 : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {}
3938 /// \brief Check init-expr for canonical loop form and save loop counter
3939 /// variable - #Var and its initialization value - #LB.
3940 bool CheckInit(Stmt *S, bool EmitDiags = true);
3941 /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags
3942 /// for less/greater and for strict/non-strict comparison.
3943 bool CheckCond(Expr *S);
3944 /// \brief Check incr-expr for canonical loop form and return true if it
3945 /// does not conform, otherwise save loop step (#Step).
3946 bool CheckInc(Expr *S);
3947 /// \brief Return the loop counter variable.
3948 ValueDecl *GetLoopDecl() const { return LCDecl; }
3949 /// \brief Return the reference expression to loop counter variable.
3950 Expr *GetLoopDeclRefExpr() const { return LCRef; }
3951 /// \brief Source range of the loop init.
3952 SourceRange GetInitSrcRange() const { return InitSrcRange; }
3953 /// \brief Source range of the loop condition.
3954 SourceRange GetConditionSrcRange() const { return ConditionSrcRange; }
3955 /// \brief Source range of the loop increment.
3956 SourceRange GetIncrementSrcRange() const { return IncrementSrcRange; }
3957 /// \brief True if the step should be subtracted.
3958 bool ShouldSubtractStep() const { return SubtractStep; }
3959 /// \brief Build the expression to calculate the number of iterations.
3961 BuildNumIterations(Scope *S, const bool LimitedType,
3962 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
3963 /// \brief Build the precondition expression for the loops.
3964 Expr *BuildPreCond(Scope *S, Expr *Cond,
3965 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
3966 /// \brief Build reference expression to the counter be used for codegen.
3967 DeclRefExpr *BuildCounterVar(llvm::MapVector<Expr *, DeclRefExpr *> &Captures,
3968 DSAStackTy &DSA) const;
3969 /// \brief Build reference expression to the private counter be used for
3971 Expr *BuildPrivateCounterVar() const;
3972 /// \brief Build initization of the counter be used for codegen.
3973 Expr *BuildCounterInit() const;
3974 /// \brief Build step of the counter be used for codegen.
3975 Expr *BuildCounterStep() const;
3976 /// \brief Return true if any expression is dependent.
3977 bool Dependent() const;
3980 /// \brief Check the right-hand side of an assignment in the increment
3982 bool CheckIncRHS(Expr *RHS);
3983 /// \brief Helper to set loop counter variable and its initializer.
3984 bool SetLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB);
3985 /// \brief Helper to set upper bound.
3986 bool SetUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR,
3988 /// \brief Helper to set loop increment.
3989 bool SetStep(Expr *NewStep, bool Subtract);
3992 bool OpenMPIterationSpaceChecker::Dependent() const {
3994 assert(!LB && !UB && !Step);
3997 return LCDecl->getType()->isDependentType() ||
3998 (LB && LB->isValueDependent()) || (UB && UB->isValueDependent()) ||
3999 (Step && Step->isValueDependent());
4002 static Expr *getExprAsWritten(Expr *E) {
4003 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(E))
4004 E = ExprTemp->getSubExpr();
4006 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
4007 E = MTE->GetTemporaryExpr();
4009 while (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
4010 E = Binder->getSubExpr();
4012 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
4013 E = ICE->getSubExprAsWritten();
4014 return E->IgnoreParens();
4017 bool OpenMPIterationSpaceChecker::SetLCDeclAndLB(ValueDecl *NewLCDecl,
4020 // State consistency checking to ensure correct usage.
4021 assert(LCDecl == nullptr && LB == nullptr && LCRef == nullptr &&
4022 UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
4023 if (!NewLCDecl || !NewLB)
4025 LCDecl = getCanonicalDecl(NewLCDecl);
4026 LCRef = NewLCRefExpr;
4027 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(NewLB))
4028 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
4029 if ((Ctor->isCopyOrMoveConstructor() ||
4030 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
4031 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
4032 NewLB = CE->getArg(0)->IgnoreParenImpCasts();
4037 bool OpenMPIterationSpaceChecker::SetUB(Expr *NewUB, bool LessOp, bool StrictOp,
4038 SourceRange SR, SourceLocation SL) {
4039 // State consistency checking to ensure correct usage.
4040 assert(LCDecl != nullptr && LB != nullptr && UB == nullptr &&
4041 Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
4045 TestIsLessOp = LessOp;
4046 TestIsStrictOp = StrictOp;
4047 ConditionSrcRange = SR;
4052 bool OpenMPIterationSpaceChecker::SetStep(Expr *NewStep, bool Subtract) {
4053 // State consistency checking to ensure correct usage.
4054 assert(LCDecl != nullptr && LB != nullptr && Step == nullptr);
4057 if (!NewStep->isValueDependent()) {
4058 // Check that the step is integer expression.
4059 SourceLocation StepLoc = NewStep->getLocStart();
4061 SemaRef.PerformOpenMPImplicitIntegerConversion(StepLoc, NewStep);
4062 if (Val.isInvalid())
4064 NewStep = Val.get();
4066 // OpenMP [2.6, Canonical Loop Form, Restrictions]
4067 // If test-expr is of form var relational-op b and relational-op is < or
4068 // <= then incr-expr must cause var to increase on each iteration of the
4069 // loop. If test-expr is of form var relational-op b and relational-op is
4070 // > or >= then incr-expr must cause var to decrease on each iteration of
4072 // If test-expr is of form b relational-op var and relational-op is < or
4073 // <= then incr-expr must cause var to decrease on each iteration of the
4074 // loop. If test-expr is of form b relational-op var and relational-op is
4075 // > or >= then incr-expr must cause var to increase on each iteration of
4077 llvm::APSInt Result;
4078 bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context);
4079 bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation();
4081 IsConstant && Result.isSigned() && (Subtract != Result.isNegative());
4083 IsConstant && Result.isSigned() && (Subtract == Result.isNegative());
4084 bool IsConstZero = IsConstant && !Result.getBoolValue();
4085 if (UB && (IsConstZero ||
4086 (TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract))
4087 : (IsConstPos || (IsUnsigned && !Subtract))))) {
4088 SemaRef.Diag(NewStep->getExprLoc(),
4089 diag::err_omp_loop_incr_not_compatible)
4090 << LCDecl << TestIsLessOp << NewStep->getSourceRange();
4091 SemaRef.Diag(ConditionLoc,
4092 diag::note_omp_loop_cond_requres_compatible_incr)
4093 << TestIsLessOp << ConditionSrcRange;
4096 if (TestIsLessOp == Subtract) {
4097 NewStep = SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus,
4099 Subtract = !Subtract;
4104 SubtractStep = Subtract;
4108 bool OpenMPIterationSpaceChecker::CheckInit(Stmt *S, bool EmitDiags) {
4109 // Check init-expr for canonical loop form and save loop counter
4110 // variable - #Var and its initialization value - #LB.
4111 // OpenMP [2.6] Canonical loop form. init-expr may be one of the following:
4113 // integer-type var = lb
4114 // random-access-iterator-type var = lb
4115 // pointer-type var = lb
4119 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_init);
4123 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
4124 if (!ExprTemp->cleanupsHaveSideEffects())
4125 S = ExprTemp->getSubExpr();
4127 InitSrcRange = S->getSourceRange();
4128 if (Expr *E = dyn_cast<Expr>(S))
4129 S = E->IgnoreParens();
4130 if (auto BO = dyn_cast<BinaryOperator>(S)) {
4131 if (BO->getOpcode() == BO_Assign) {
4132 auto *LHS = BO->getLHS()->IgnoreParens();
4133 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
4134 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
4135 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
4136 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4137 return SetLCDeclAndLB(DRE->getDecl(), DRE, BO->getRHS());
4139 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
4140 if (ME->isArrow() &&
4141 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
4142 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4145 } else if (auto DS = dyn_cast<DeclStmt>(S)) {
4146 if (DS->isSingleDecl()) {
4147 if (auto Var = dyn_cast_or_null<VarDecl>(DS->getSingleDecl())) {
4148 if (Var->hasInit() && !Var->getType()->isReferenceType()) {
4149 // Accept non-canonical init form here but emit ext. warning.
4150 if (Var->getInitStyle() != VarDecl::CInit && EmitDiags)
4151 SemaRef.Diag(S->getLocStart(),
4152 diag::ext_omp_loop_not_canonical_init)
4153 << S->getSourceRange();
4154 return SetLCDeclAndLB(Var, nullptr, Var->getInit());
4158 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) {
4159 if (CE->getOperator() == OO_Equal) {
4160 auto *LHS = CE->getArg(0);
4161 if (auto DRE = dyn_cast<DeclRefExpr>(LHS)) {
4162 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
4163 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
4164 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4165 return SetLCDeclAndLB(DRE->getDecl(), DRE, CE->getArg(1));
4167 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
4168 if (ME->isArrow() &&
4169 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
4170 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
4175 if (Dependent() || SemaRef.CurContext->isDependentContext())
4178 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_init)
4179 << S->getSourceRange();
4184 /// \brief Ignore parenthesizes, implicit casts, copy constructor and return the
4185 /// variable (which may be the loop variable) if possible.
4186 static const ValueDecl *GetInitLCDecl(Expr *E) {
4189 E = getExprAsWritten(E);
4190 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(E))
4191 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
4192 if ((Ctor->isCopyOrMoveConstructor() ||
4193 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
4194 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
4195 E = CE->getArg(0)->IgnoreParenImpCasts();
4196 if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
4197 if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
4198 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
4199 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
4200 return getCanonicalDecl(ME->getMemberDecl());
4201 return getCanonicalDecl(VD);
4204 if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
4205 if (ME->isArrow() && isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
4206 return getCanonicalDecl(ME->getMemberDecl());
4210 bool OpenMPIterationSpaceChecker::CheckCond(Expr *S) {
4211 // Check test-expr for canonical form, save upper-bound UB, flags for
4212 // less/greater and for strict/non-strict comparison.
4213 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
4214 // var relational-op b
4215 // b relational-op var
4218 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_cond) << LCDecl;
4221 S = getExprAsWritten(S);
4222 SourceLocation CondLoc = S->getLocStart();
4223 if (auto BO = dyn_cast<BinaryOperator>(S)) {
4224 if (BO->isRelationalOp()) {
4225 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4226 return SetUB(BO->getRHS(),
4227 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_LE),
4228 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
4229 BO->getSourceRange(), BO->getOperatorLoc());
4230 if (GetInitLCDecl(BO->getRHS()) == LCDecl)
4231 return SetUB(BO->getLHS(),
4232 (BO->getOpcode() == BO_GT || BO->getOpcode() == BO_GE),
4233 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
4234 BO->getSourceRange(), BO->getOperatorLoc());
4236 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) {
4237 if (CE->getNumArgs() == 2) {
4238 auto Op = CE->getOperator();
4241 case OO_GreaterEqual:
4244 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4245 return SetUB(CE->getArg(1), Op == OO_Less || Op == OO_LessEqual,
4246 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
4247 CE->getOperatorLoc());
4248 if (GetInitLCDecl(CE->getArg(1)) == LCDecl)
4249 return SetUB(CE->getArg(0), Op == OO_Greater || Op == OO_GreaterEqual,
4250 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
4251 CE->getOperatorLoc());
4258 if (Dependent() || SemaRef.CurContext->isDependentContext())
4260 SemaRef.Diag(CondLoc, diag::err_omp_loop_not_canonical_cond)
4261 << S->getSourceRange() << LCDecl;
4265 bool OpenMPIterationSpaceChecker::CheckIncRHS(Expr *RHS) {
4266 // RHS of canonical loop form increment can be:
4271 RHS = RHS->IgnoreParenImpCasts();
4272 if (auto BO = dyn_cast<BinaryOperator>(RHS)) {
4273 if (BO->isAdditiveOp()) {
4274 bool IsAdd = BO->getOpcode() == BO_Add;
4275 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4276 return SetStep(BO->getRHS(), !IsAdd);
4277 if (IsAdd && GetInitLCDecl(BO->getRHS()) == LCDecl)
4278 return SetStep(BO->getLHS(), false);
4280 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(RHS)) {
4281 bool IsAdd = CE->getOperator() == OO_Plus;
4282 if ((IsAdd || CE->getOperator() == OO_Minus) && CE->getNumArgs() == 2) {
4283 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4284 return SetStep(CE->getArg(1), !IsAdd);
4285 if (IsAdd && GetInitLCDecl(CE->getArg(1)) == LCDecl)
4286 return SetStep(CE->getArg(0), false);
4289 if (Dependent() || SemaRef.CurContext->isDependentContext())
4291 SemaRef.Diag(RHS->getLocStart(), diag::err_omp_loop_not_canonical_incr)
4292 << RHS->getSourceRange() << LCDecl;
4296 bool OpenMPIterationSpaceChecker::CheckInc(Expr *S) {
4297 // Check incr-expr for canonical loop form and return true if it
4298 // does not conform.
4299 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
4311 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_incr) << LCDecl;
4314 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
4315 if (!ExprTemp->cleanupsHaveSideEffects())
4316 S = ExprTemp->getSubExpr();
4318 IncrementSrcRange = S->getSourceRange();
4319 S = S->IgnoreParens();
4320 if (auto UO = dyn_cast<UnaryOperator>(S)) {
4321 if (UO->isIncrementDecrementOp() &&
4322 GetInitLCDecl(UO->getSubExpr()) == LCDecl)
4324 SemaRef.ActOnIntegerConstant(UO->getLocStart(),
4325 (UO->isDecrementOp() ? -1 : 1)).get(),
4327 } else if (auto BO = dyn_cast<BinaryOperator>(S)) {
4328 switch (BO->getOpcode()) {
4331 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4332 return SetStep(BO->getRHS(), BO->getOpcode() == BO_SubAssign);
4335 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
4336 return CheckIncRHS(BO->getRHS());
4341 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) {
4342 switch (CE->getOperator()) {
4345 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4347 SemaRef.ActOnIntegerConstant(
4349 ((CE->getOperator() == OO_MinusMinus) ? -1 : 1)).get(),
4354 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4355 return SetStep(CE->getArg(1), CE->getOperator() == OO_MinusEqual);
4358 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
4359 return CheckIncRHS(CE->getArg(1));
4365 if (Dependent() || SemaRef.CurContext->isDependentContext())
4367 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_incr)
4368 << S->getSourceRange() << LCDecl;
4373 tryBuildCapture(Sema &SemaRef, Expr *Capture,
4374 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4375 if (SemaRef.CurContext->isDependentContext())
4376 return ExprResult(Capture);
4377 if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects))
4378 return SemaRef.PerformImplicitConversion(
4379 Capture->IgnoreImpCasts(), Capture->getType(), Sema::AA_Converting,
4380 /*AllowExplicit=*/true);
4381 auto I = Captures.find(Capture);
4382 if (I != Captures.end())
4383 return buildCapture(SemaRef, Capture, I->second);
4384 DeclRefExpr *Ref = nullptr;
4385 ExprResult Res = buildCapture(SemaRef, Capture, Ref);
4386 Captures[Capture] = Ref;
4390 /// \brief Build the expression to calculate the number of iterations.
4391 Expr *OpenMPIterationSpaceChecker::BuildNumIterations(
4392 Scope *S, const bool LimitedType,
4393 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
4395 auto VarType = LCDecl->getType().getNonReferenceType();
4396 if (VarType->isIntegerType() || VarType->isPointerType() ||
4397 SemaRef.getLangOpts().CPlusPlus) {
4399 auto *UBExpr = TestIsLessOp ? UB : LB;
4400 auto *LBExpr = TestIsLessOp ? LB : UB;
4401 Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get();
4402 Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get();
4403 if (!Upper || !Lower)
4406 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Sub, Upper, Lower);
4408 if (!Diff.isUsable() && VarType->getAsCXXRecordDecl()) {
4409 // BuildBinOp already emitted error, this one is to point user to upper
4410 // and lower bound, and to tell what is passed to 'operator-'.
4411 SemaRef.Diag(Upper->getLocStart(), diag::err_omp_loop_diff_cxx)
4412 << Upper->getSourceRange() << Lower->getSourceRange();
4417 if (!Diff.isUsable())
4420 // Upper - Lower [- 1]
4422 Diff = SemaRef.BuildBinOp(
4423 S, DefaultLoc, BO_Sub, Diff.get(),
4424 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
4425 if (!Diff.isUsable())
4428 // Upper - Lower [- 1] + Step
4429 auto NewStep = tryBuildCapture(SemaRef, Step, Captures);
4430 if (!NewStep.isUsable())
4432 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Add, Diff.get(), NewStep.get());
4433 if (!Diff.isUsable())
4436 // Parentheses (for dumping/debugging purposes only).
4437 Diff = SemaRef.ActOnParenExpr(DefaultLoc, DefaultLoc, Diff.get());
4438 if (!Diff.isUsable())
4441 // (Upper - Lower [- 1] + Step) / Step
4442 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Div, Diff.get(), NewStep.get());
4443 if (!Diff.isUsable())
4446 // OpenMP runtime requires 32-bit or 64-bit loop variables.
4447 QualType Type = Diff.get()->getType();
4448 auto &C = SemaRef.Context;
4449 bool UseVarType = VarType->hasIntegerRepresentation() &&
4450 C.getTypeSize(Type) > C.getTypeSize(VarType);
4451 if (!Type->isIntegerType() || UseVarType) {
4453 UseVarType ? C.getTypeSize(VarType) : C.getTypeSize(Type);
4454 bool IsSigned = UseVarType ? VarType->hasSignedIntegerRepresentation()
4455 : Type->hasSignedIntegerRepresentation();
4456 Type = C.getIntTypeForBitwidth(NewSize, IsSigned);
4457 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), Type)) {
4458 Diff = SemaRef.PerformImplicitConversion(
4459 Diff.get(), Type, Sema::AA_Converting, /*AllowExplicit=*/true);
4460 if (!Diff.isUsable())
4465 unsigned NewSize = (C.getTypeSize(Type) > 32) ? 64 : 32;
4466 if (NewSize != C.getTypeSize(Type)) {
4467 if (NewSize < C.getTypeSize(Type)) {
4468 assert(NewSize == 64 && "incorrect loop var size");
4469 SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var)
4470 << InitSrcRange << ConditionSrcRange;
4472 QualType NewType = C.getIntTypeForBitwidth(
4473 NewSize, Type->hasSignedIntegerRepresentation() ||
4474 C.getTypeSize(Type) < NewSize);
4475 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), NewType)) {
4476 Diff = SemaRef.PerformImplicitConversion(Diff.get(), NewType,
4477 Sema::AA_Converting, true);
4478 if (!Diff.isUsable())
4487 Expr *OpenMPIterationSpaceChecker::BuildPreCond(
4488 Scope *S, Expr *Cond,
4489 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
4490 // Try to build LB <op> UB, where <op> is <, >, <=, or >=.
4491 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
4492 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
4494 auto NewLB = tryBuildCapture(SemaRef, LB, Captures);
4495 auto NewUB = tryBuildCapture(SemaRef, UB, Captures);
4496 if (!NewLB.isUsable() || !NewUB.isUsable())
4499 auto CondExpr = SemaRef.BuildBinOp(
4500 S, DefaultLoc, TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE)
4501 : (TestIsStrictOp ? BO_GT : BO_GE),
4502 NewLB.get(), NewUB.get());
4503 if (CondExpr.isUsable()) {
4504 if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(),
4505 SemaRef.Context.BoolTy))
4506 CondExpr = SemaRef.PerformImplicitConversion(
4507 CondExpr.get(), SemaRef.Context.BoolTy, /*Action=*/Sema::AA_Casting,
4508 /*AllowExplicit=*/true);
4510 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
4511 // Otherwise use original loop conditon and evaluate it in runtime.
4512 return CondExpr.isUsable() ? CondExpr.get() : Cond;
4515 /// \brief Build reference expression to the counter be used for codegen.
4516 DeclRefExpr *OpenMPIterationSpaceChecker::BuildCounterVar(
4517 llvm::MapVector<Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const {
4518 auto *VD = dyn_cast<VarDecl>(LCDecl);
4520 VD = SemaRef.IsOpenMPCapturedDecl(LCDecl);
4521 auto *Ref = buildDeclRefExpr(
4522 SemaRef, VD, VD->getType().getNonReferenceType(), DefaultLoc);
4523 DSAStackTy::DSAVarData Data = DSA.getTopDSA(LCDecl, /*FromParent=*/false);
4524 // If the loop control decl is explicitly marked as private, do not mark it
4525 // as captured again.
4526 if (!isOpenMPPrivate(Data.CKind) || !Data.RefExpr)
4527 Captures.insert(std::make_pair(LCRef, Ref));
4530 return buildDeclRefExpr(SemaRef, VD, VD->getType().getNonReferenceType(),
4534 Expr *OpenMPIterationSpaceChecker::BuildPrivateCounterVar() const {
4535 if (LCDecl && !LCDecl->isInvalidDecl()) {
4536 auto Type = LCDecl->getType().getNonReferenceType();
4538 buildVarDecl(SemaRef, DefaultLoc, Type, LCDecl->getName(),
4539 LCDecl->hasAttrs() ? &LCDecl->getAttrs() : nullptr);
4540 if (PrivateVar->isInvalidDecl())
4542 return buildDeclRefExpr(SemaRef, PrivateVar, Type, DefaultLoc);
4547 /// \brief Build initization of the counter be used for codegen.
4548 Expr *OpenMPIterationSpaceChecker::BuildCounterInit() const { return LB; }
4550 /// \brief Build step of the counter be used for codegen.
4551 Expr *OpenMPIterationSpaceChecker::BuildCounterStep() const { return Step; }
4553 /// \brief Iteration space of a single for loop.
4554 struct LoopIterationSpace final {
4555 /// \brief Condition of the loop.
4556 Expr *PreCond = nullptr;
4557 /// \brief This expression calculates the number of iterations in the loop.
4558 /// It is always possible to calculate it before starting the loop.
4559 Expr *NumIterations = nullptr;
4560 /// \brief The loop counter variable.
4561 Expr *CounterVar = nullptr;
4562 /// \brief Private loop counter variable.
4563 Expr *PrivateCounterVar = nullptr;
4564 /// \brief This is initializer for the initial value of #CounterVar.
4565 Expr *CounterInit = nullptr;
4566 /// \brief This is step for the #CounterVar used to generate its update:
4567 /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration.
4568 Expr *CounterStep = nullptr;
4569 /// \brief Should step be subtracted?
4570 bool Subtract = false;
4571 /// \brief Source range of the loop init.
4572 SourceRange InitSrcRange;
4573 /// \brief Source range of the loop condition.
4574 SourceRange CondSrcRange;
4575 /// \brief Source range of the loop increment.
4576 SourceRange IncSrcRange;
4581 void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) {
4582 assert(getLangOpts().OpenMP && "OpenMP is not active.");
4583 assert(Init && "Expected loop in canonical form.");
4584 unsigned AssociatedLoops = DSAStack->getAssociatedLoops();
4585 if (AssociatedLoops > 0 &&
4586 isOpenMPLoopDirective(DSAStack->getCurrentDirective())) {
4587 OpenMPIterationSpaceChecker ISC(*this, ForLoc);
4588 if (!ISC.CheckInit(Init, /*EmitDiags=*/false)) {
4589 if (auto *D = ISC.GetLoopDecl()) {
4590 auto *VD = dyn_cast<VarDecl>(D);
4592 if (auto *Private = IsOpenMPCapturedDecl(D))
4595 auto *Ref = buildCapture(*this, D, ISC.GetLoopDeclRefExpr(),
4596 /*WithInit=*/false);
4597 VD = cast<VarDecl>(Ref->getDecl());
4600 DSAStack->addLoopControlVariable(D, VD);
4603 DSAStack->setAssociatedLoops(AssociatedLoops - 1);
4607 /// \brief Called on a for stmt to check and extract its iteration space
4608 /// for further processing (such as collapsing).
4609 static bool CheckOpenMPIterationSpace(
4610 OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA,
4611 unsigned CurrentNestedLoopCount, unsigned NestedLoopCount,
4612 Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr,
4613 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
4614 LoopIterationSpace &ResultIterSpace,
4615 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4616 // OpenMP [2.6, Canonical Loop Form]
4617 // for (init-expr; test-expr; incr-expr) structured-block
4618 auto For = dyn_cast_or_null<ForStmt>(S);
4620 SemaRef.Diag(S->getLocStart(), diag::err_omp_not_for)
4621 << (CollapseLoopCountExpr != nullptr || OrderedLoopCountExpr != nullptr)
4622 << getOpenMPDirectiveName(DKind) << NestedLoopCount
4623 << (CurrentNestedLoopCount > 0) << CurrentNestedLoopCount;
4624 if (NestedLoopCount > 1) {
4625 if (CollapseLoopCountExpr && OrderedLoopCountExpr)
4626 SemaRef.Diag(DSA.getConstructLoc(),
4627 diag::note_omp_collapse_ordered_expr)
4628 << 2 << CollapseLoopCountExpr->getSourceRange()
4629 << OrderedLoopCountExpr->getSourceRange();
4630 else if (CollapseLoopCountExpr)
4631 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
4632 diag::note_omp_collapse_ordered_expr)
4633 << 0 << CollapseLoopCountExpr->getSourceRange();
4635 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
4636 diag::note_omp_collapse_ordered_expr)
4637 << 1 << OrderedLoopCountExpr->getSourceRange();
4641 assert(For->getBody());
4643 OpenMPIterationSpaceChecker ISC(SemaRef, For->getForLoc());
4646 auto Init = For->getInit();
4647 if (ISC.CheckInit(Init))
4650 bool HasErrors = false;
4652 // Check loop variable's type.
4653 if (auto *LCDecl = ISC.GetLoopDecl()) {
4654 auto *LoopDeclRefExpr = ISC.GetLoopDeclRefExpr();
4656 // OpenMP [2.6, Canonical Loop Form]
4657 // Var is one of the following:
4658 // A variable of signed or unsigned integer type.
4659 // For C++, a variable of a random access iterator type.
4660 // For C, a variable of a pointer type.
4661 auto VarType = LCDecl->getType().getNonReferenceType();
4662 if (!VarType->isDependentType() && !VarType->isIntegerType() &&
4663 !VarType->isPointerType() &&
4664 !(SemaRef.getLangOpts().CPlusPlus && VarType->isOverloadableType())) {
4665 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_variable_type)
4666 << SemaRef.getLangOpts().CPlusPlus;
4670 // OpenMP, 2.14.1.1 Data-sharing Attribute Rules for Variables Referenced in
4672 // The loop iteration variable(s) in the associated for-loop(s) of a for or
4673 // parallel for construct is (are) private.
4674 // The loop iteration variable in the associated for-loop of a simd
4675 // construct with just one associated for-loop is linear with a
4676 // constant-linear-step that is the increment of the associated for-loop.
4677 // Exclude loop var from the list of variables with implicitly defined data
4678 // sharing attributes.
4679 VarsWithImplicitDSA.erase(LCDecl);
4681 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
4682 // in a Construct, C/C++].
4683 // The loop iteration variable in the associated for-loop of a simd
4684 // construct with just one associated for-loop may be listed in a linear
4685 // clause with a constant-linear-step that is the increment of the
4686 // associated for-loop.
4687 // The loop iteration variable(s) in the associated for-loop(s) of a for or
4688 // parallel for construct may be listed in a private or lastprivate clause.
4689 DSAStackTy::DSAVarData DVar = DSA.getTopDSA(LCDecl, false);
4690 // If LoopVarRefExpr is nullptr it means the corresponding loop variable is
4691 // declared in the loop and it is predetermined as a private.
4692 auto PredeterminedCKind =
4693 isOpenMPSimdDirective(DKind)
4694 ? ((NestedLoopCount == 1) ? OMPC_linear : OMPC_lastprivate)
4696 if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
4697 DVar.CKind != PredeterminedCKind) ||
4698 ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop ||
4699 isOpenMPDistributeDirective(DKind)) &&
4700 !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
4701 DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) &&
4702 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
4703 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_var_dsa)
4704 << getOpenMPClauseName(DVar.CKind) << getOpenMPDirectiveName(DKind)
4705 << getOpenMPClauseName(PredeterminedCKind);
4706 if (DVar.RefExpr == nullptr)
4707 DVar.CKind = PredeterminedCKind;
4708 ReportOriginalDSA(SemaRef, &DSA, LCDecl, DVar, /*IsLoopIterVar=*/true);
4710 } else if (LoopDeclRefExpr != nullptr) {
4711 // Make the loop iteration variable private (for worksharing constructs),
4712 // linear (for simd directives with the only one associated loop) or
4713 // lastprivate (for simd directives with several collapsed or ordered
4715 if (DVar.CKind == OMPC_unknown)
4716 DVar = DSA.hasDSA(LCDecl, isOpenMPPrivate,
4717 [](OpenMPDirectiveKind) -> bool { return true; },
4718 /*FromParent=*/false);
4719 DSA.addDSA(LCDecl, LoopDeclRefExpr, PredeterminedCKind);
4722 assert(isOpenMPLoopDirective(DKind) && "DSA for non-loop vars");
4725 HasErrors |= ISC.CheckCond(For->getCond());
4728 HasErrors |= ISC.CheckInc(For->getInc());
4731 if (ISC.Dependent() || SemaRef.CurContext->isDependentContext() || HasErrors)
4734 // Build the loop's iteration space representation.
4735 ResultIterSpace.PreCond =
4736 ISC.BuildPreCond(DSA.getCurScope(), For->getCond(), Captures);
4737 ResultIterSpace.NumIterations = ISC.BuildNumIterations(
4739 (isOpenMPWorksharingDirective(DKind) ||
4740 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)),
4742 ResultIterSpace.CounterVar = ISC.BuildCounterVar(Captures, DSA);
4743 ResultIterSpace.PrivateCounterVar = ISC.BuildPrivateCounterVar();
4744 ResultIterSpace.CounterInit = ISC.BuildCounterInit();
4745 ResultIterSpace.CounterStep = ISC.BuildCounterStep();
4746 ResultIterSpace.InitSrcRange = ISC.GetInitSrcRange();
4747 ResultIterSpace.CondSrcRange = ISC.GetConditionSrcRange();
4748 ResultIterSpace.IncSrcRange = ISC.GetIncrementSrcRange();
4749 ResultIterSpace.Subtract = ISC.ShouldSubtractStep();
4751 HasErrors |= (ResultIterSpace.PreCond == nullptr ||
4752 ResultIterSpace.NumIterations == nullptr ||
4753 ResultIterSpace.CounterVar == nullptr ||
4754 ResultIterSpace.PrivateCounterVar == nullptr ||
4755 ResultIterSpace.CounterInit == nullptr ||
4756 ResultIterSpace.CounterStep == nullptr);
4761 /// \brief Build 'VarRef = Start.
4763 BuildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef,
4765 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4766 // Build 'VarRef = Start.
4767 auto NewStart = tryBuildCapture(SemaRef, Start.get(), Captures);
4768 if (!NewStart.isUsable())
4770 if (!SemaRef.Context.hasSameType(NewStart.get()->getType(),
4771 VarRef.get()->getType())) {
4772 NewStart = SemaRef.PerformImplicitConversion(
4773 NewStart.get(), VarRef.get()->getType(), Sema::AA_Converting,
4774 /*AllowExplicit=*/true);
4775 if (!NewStart.isUsable())
4780 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
4784 /// \brief Build 'VarRef = Start + Iter * Step'.
4786 BuildCounterUpdate(Sema &SemaRef, Scope *S, SourceLocation Loc,
4787 ExprResult VarRef, ExprResult Start, ExprResult Iter,
4788 ExprResult Step, bool Subtract,
4789 llvm::MapVector<Expr *, DeclRefExpr *> *Captures = nullptr) {
4790 // Add parentheses (for debugging purposes only).
4791 Iter = SemaRef.ActOnParenExpr(Loc, Loc, Iter.get());
4792 if (!VarRef.isUsable() || !Start.isUsable() || !Iter.isUsable() ||
4796 ExprResult NewStep = Step;
4798 NewStep = tryBuildCapture(SemaRef, Step.get(), *Captures);
4799 if (NewStep.isInvalid())
4802 SemaRef.BuildBinOp(S, Loc, BO_Mul, Iter.get(), NewStep.get());
4803 if (!Update.isUsable())
4806 // Try to build 'VarRef = Start, VarRef (+|-)= Iter * Step' or
4807 // 'VarRef = Start (+|-) Iter * Step'.
4808 ExprResult NewStart = Start;
4810 NewStart = tryBuildCapture(SemaRef, Start.get(), *Captures);
4811 if (NewStart.isInvalid())
4814 // First attempt: try to build 'VarRef = Start, VarRef += Iter * Step'.
4815 ExprResult SavedUpdate = Update;
4816 ExprResult UpdateVal;
4817 if (VarRef.get()->getType()->isOverloadableType() ||
4818 NewStart.get()->getType()->isOverloadableType() ||
4819 Update.get()->getType()->isOverloadableType()) {
4820 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
4821 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
4823 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
4824 if (Update.isUsable()) {
4826 SemaRef.BuildBinOp(S, Loc, Subtract ? BO_SubAssign : BO_AddAssign,
4827 VarRef.get(), SavedUpdate.get());
4828 if (UpdateVal.isUsable()) {
4829 Update = SemaRef.CreateBuiltinBinOp(Loc, BO_Comma, Update.get(),
4833 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
4836 // Second attempt: try to build 'VarRef = Start (+|-) Iter * Step'.
4837 if (!Update.isUsable() || !UpdateVal.isUsable()) {
4838 Update = SemaRef.BuildBinOp(S, Loc, Subtract ? BO_Sub : BO_Add,
4839 NewStart.get(), SavedUpdate.get());
4840 if (!Update.isUsable())
4843 if (!SemaRef.Context.hasSameType(Update.get()->getType(),
4844 VarRef.get()->getType())) {
4845 Update = SemaRef.PerformImplicitConversion(
4846 Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true);
4847 if (!Update.isUsable())
4851 Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get());
4856 /// \brief Convert integer expression \a E to make it have at least \a Bits
4858 static ExprResult WidenIterationCount(unsigned Bits, Expr *E,
4862 auto &C = SemaRef.Context;
4863 QualType OldType = E->getType();
4864 unsigned HasBits = C.getTypeSize(OldType);
4865 if (HasBits >= Bits)
4866 return ExprResult(E);
4867 // OK to convert to signed, because new type has more bits than old.
4868 QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
4869 return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
4873 /// \brief Check if the given expression \a E is a constant integer that fits
4874 /// into \a Bits bits.
4875 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
4878 llvm::APSInt Result;
4879 if (E->isIntegerConstantExpr(Result, SemaRef.Context))
4880 return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits);
4884 /// Build preinits statement for the given declarations.
4885 static Stmt *buildPreInits(ASTContext &Context,
4886 SmallVectorImpl<Decl *> &PreInits) {
4887 if (!PreInits.empty()) {
4888 return new (Context) DeclStmt(
4889 DeclGroupRef::Create(Context, PreInits.begin(), PreInits.size()),
4890 SourceLocation(), SourceLocation());
4895 /// Build preinits statement for the given declarations.
4896 static Stmt *buildPreInits(ASTContext &Context,
4897 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
4898 if (!Captures.empty()) {
4899 SmallVector<Decl *, 16> PreInits;
4900 for (auto &Pair : Captures)
4901 PreInits.push_back(Pair.second->getDecl());
4902 return buildPreInits(Context, PreInits);
4907 /// Build postupdate expression for the given list of postupdates expressions.
4908 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
4909 Expr *PostUpdate = nullptr;
4910 if (!PostUpdates.empty()) {
4911 for (auto *E : PostUpdates) {
4912 Expr *ConvE = S.BuildCStyleCastExpr(
4914 S.Context.getTrivialTypeSourceInfo(S.Context.VoidTy),
4917 PostUpdate = PostUpdate
4918 ? S.CreateBuiltinBinOp(ConvE->getExprLoc(), BO_Comma,
4927 /// \brief Called on a for stmt to check itself and nested loops (if any).
4928 /// \return Returns 0 if one of the collapsed stmts is not canonical for loop,
4929 /// number of collapsed loops otherwise.
4931 CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
4932 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
4934 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
4935 OMPLoopDirective::HelperExprs &Built) {
4936 unsigned NestedLoopCount = 1;
4937 if (CollapseLoopCountExpr) {
4938 // Found 'collapse' clause - calculate collapse number.
4939 llvm::APSInt Result;
4940 if (CollapseLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext()))
4941 NestedLoopCount = Result.getLimitedValue();
4943 if (OrderedLoopCountExpr) {
4944 // Found 'ordered' clause - calculate collapse number.
4945 llvm::APSInt Result;
4946 if (OrderedLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) {
4947 if (Result.getLimitedValue() < NestedLoopCount) {
4948 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
4949 diag::err_omp_wrong_ordered_loop_count)
4950 << OrderedLoopCountExpr->getSourceRange();
4951 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
4952 diag::note_collapse_loop_count)
4953 << CollapseLoopCountExpr->getSourceRange();
4955 NestedLoopCount = Result.getLimitedValue();
4958 // This is helper routine for loop directives (e.g., 'for', 'simd',
4959 // 'for simd', etc.).
4960 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
4961 SmallVector<LoopIterationSpace, 4> IterSpaces;
4962 IterSpaces.resize(NestedLoopCount);
4963 Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true);
4964 for (unsigned Cnt = 0; Cnt < NestedLoopCount; ++Cnt) {
4965 if (CheckOpenMPIterationSpace(DKind, CurStmt, SemaRef, DSA, Cnt,
4966 NestedLoopCount, CollapseLoopCountExpr,
4967 OrderedLoopCountExpr, VarsWithImplicitDSA,
4968 IterSpaces[Cnt], Captures))
4970 // Move on to the next nested for loop, or to the loop body.
4971 // OpenMP [2.8.1, simd construct, Restrictions]
4972 // All loops associated with the construct must be perfectly nested; that
4973 // is, there must be no intervening code nor any OpenMP directive between
4975 CurStmt = cast<ForStmt>(CurStmt)->getBody()->IgnoreContainers();
4978 Built.clear(/* size */ NestedLoopCount);
4980 if (SemaRef.CurContext->isDependentContext())
4981 return NestedLoopCount;
4983 // An example of what is generated for the following code:
4985 // #pragma omp simd collapse(2) ordered(2)
4986 // for (i = 0; i < NI; ++i)
4987 // for (k = 0; k < NK; ++k)
4988 // for (j = J0; j < NJ; j+=2) {
4992 // We generate the code below.
4993 // Note: the loop body may be outlined in CodeGen.
4994 // Note: some counters may be C++ classes, operator- is used to find number of
4995 // iterations and operator+= to calculate counter value.
4996 // Note: decltype(NumIterations) must be integer type (in 'omp for', only i32
4997 // or i64 is currently supported).
4999 // #define NumIterations (NI * ((NJ - J0 - 1 + 2) / 2))
5000 // for (int[32|64]_t IV = 0; IV < NumIterations; ++IV ) {
5001 // .local.i = IV / ((NJ - J0 - 1 + 2) / 2);
5002 // .local.j = J0 + (IV % ((NJ - J0 - 1 + 2) / 2)) * 2;
5003 // // similar updates for vars in clauses (e.g. 'linear')
5004 // <loop body (using local i and j)>
5006 // i = NI; // assign final values of counters
5010 // Last iteration number is (I1 * I2 * ... In) - 1, where I1, I2 ... In are
5011 // the iteration counts of the collapsed for loops.
5012 // Precondition tests if there is at least one iteration (all conditions are
5014 auto PreCond = ExprResult(IterSpaces[0].PreCond);
5015 auto N0 = IterSpaces[0].NumIterations;
5016 ExprResult LastIteration32 = WidenIterationCount(
5017 32 /* Bits */, SemaRef.PerformImplicitConversion(
5018 N0->IgnoreImpCasts(), N0->getType(),
5019 Sema::AA_Converting, /*AllowExplicit=*/true)
5022 ExprResult LastIteration64 = WidenIterationCount(
5023 64 /* Bits */, SemaRef.PerformImplicitConversion(
5024 N0->IgnoreImpCasts(), N0->getType(),
5025 Sema::AA_Converting, /*AllowExplicit=*/true)
5029 if (!LastIteration32.isUsable() || !LastIteration64.isUsable())
5030 return NestedLoopCount;
5032 auto &C = SemaRef.Context;
5033 bool AllCountsNeedLessThan32Bits = C.getTypeSize(N0->getType()) < 32;
5035 Scope *CurScope = DSA.getCurScope();
5036 for (unsigned Cnt = 1; Cnt < NestedLoopCount; ++Cnt) {
5037 if (PreCond.isUsable()) {
5038 PreCond = SemaRef.BuildBinOp(CurScope, SourceLocation(), BO_LAnd,
5039 PreCond.get(), IterSpaces[Cnt].PreCond);
5041 auto N = IterSpaces[Cnt].NumIterations;
5042 AllCountsNeedLessThan32Bits &= C.getTypeSize(N->getType()) < 32;
5043 if (LastIteration32.isUsable())
5044 LastIteration32 = SemaRef.BuildBinOp(
5045 CurScope, SourceLocation(), BO_Mul, LastIteration32.get(),
5046 SemaRef.PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
5047 Sema::AA_Converting,
5048 /*AllowExplicit=*/true)
5050 if (LastIteration64.isUsable())
5051 LastIteration64 = SemaRef.BuildBinOp(
5052 CurScope, SourceLocation(), BO_Mul, LastIteration64.get(),
5053 SemaRef.PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
5054 Sema::AA_Converting,
5055 /*AllowExplicit=*/true)
5059 // Choose either the 32-bit or 64-bit version.
5060 ExprResult LastIteration = LastIteration64;
5061 if (LastIteration32.isUsable() &&
5062 C.getTypeSize(LastIteration32.get()->getType()) == 32 &&
5063 (AllCountsNeedLessThan32Bits || NestedLoopCount == 1 ||
5066 LastIteration32.get()->getType()->hasSignedIntegerRepresentation(),
5067 LastIteration64.get(), SemaRef)))
5068 LastIteration = LastIteration32;
5069 QualType VType = LastIteration.get()->getType();
5070 QualType RealVType = VType;
5071 QualType StrideVType = VType;
5072 if (isOpenMPTaskLoopDirective(DKind)) {
5074 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
5076 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
5079 if (!LastIteration.isUsable())
5082 // Save the number of iterations.
5083 ExprResult NumIterations = LastIteration;
5085 LastIteration = SemaRef.BuildBinOp(
5086 CurScope, SourceLocation(), BO_Sub, LastIteration.get(),
5087 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
5088 if (!LastIteration.isUsable())
5092 // Calculate the last iteration number beforehand instead of doing this on
5093 // each iteration. Do not do this if the number of iterations may be kfold-ed.
5094 llvm::APSInt Result;
5096 LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context);
5097 ExprResult CalcLastIteration;
5099 ExprResult SaveRef =
5100 tryBuildCapture(SemaRef, LastIteration.get(), Captures);
5101 LastIteration = SaveRef;
5103 // Prepare SaveRef + 1.
5104 NumIterations = SemaRef.BuildBinOp(
5105 CurScope, SourceLocation(), BO_Add, SaveRef.get(),
5106 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
5107 if (!NumIterations.isUsable())
5111 SourceLocation InitLoc = IterSpaces[0].InitSrcRange.getBegin();
5113 // Build variables passed into runtime, nesessary for worksharing directives.
5114 ExprResult LB, UB, IL, ST, EUB, PrevLB, PrevUB;
5115 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
5116 isOpenMPDistributeDirective(DKind)) {
5117 // Lower bound variable, initialized with zero.
5118 VarDecl *LBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.lb");
5119 LB = buildDeclRefExpr(SemaRef, LBDecl, VType, InitLoc);
5120 SemaRef.AddInitializerToDecl(
5121 LBDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
5122 /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
5124 // Upper bound variable, initialized with last iteration number.
5125 VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
5126 UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
5127 SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
5128 /*DirectInit*/ false,
5129 /*TypeMayContainAuto*/ false);
5131 // A 32-bit variable-flag where runtime returns 1 for the last iteration.
5132 // This will be used to implement clause 'lastprivate'.
5133 QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
5134 VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
5135 IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
5136 SemaRef.AddInitializerToDecl(
5137 ILDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
5138 /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
5140 // Stride variable returned by runtime (we initialize it to 1 by default).
5142 buildVarDecl(SemaRef, InitLoc, StrideVType, ".omp.stride");
5143 ST = buildDeclRefExpr(SemaRef, STDecl, StrideVType, InitLoc);
5144 SemaRef.AddInitializerToDecl(
5145 STDecl, SemaRef.ActOnIntegerConstant(InitLoc, 1).get(),
5146 /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
5148 // Build expression: UB = min(UB, LastIteration)
5149 // It is nesessary for CodeGen of directives with static scheduling.
5150 ExprResult IsUBGreater = SemaRef.BuildBinOp(CurScope, InitLoc, BO_GT,
5151 UB.get(), LastIteration.get());
5152 ExprResult CondOp = SemaRef.ActOnConditionalOp(
5153 InitLoc, InitLoc, IsUBGreater.get(), LastIteration.get(), UB.get());
5154 EUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, UB.get(),
5156 EUB = SemaRef.ActOnFinishFullExpr(EUB.get());
5158 // If we have a combined directive that combines 'distribute', 'for' or
5159 // 'simd' we need to be able to access the bounds of the schedule of the
5160 // enclosing region. E.g. in 'distribute parallel for' the bounds obtained
5161 // by scheduling 'distribute' have to be passed to the schedule of 'for'.
5162 if (isOpenMPLoopBoundSharingDirective(DKind)) {
5163 auto *CD = cast<CapturedStmt>(AStmt)->getCapturedDecl();
5165 // We expect to have at least 2 more parameters than the 'parallel'
5166 // directive does - the lower and upper bounds of the previous schedule.
5167 assert(CD->getNumParams() >= 4 &&
5168 "Unexpected number of parameters in loop combined directive");
5170 // Set the proper type for the bounds given what we learned from the
5172 auto *PrevLBDecl = CD->getParam(/*PrevLB=*/2);
5173 auto *PrevUBDecl = CD->getParam(/*PrevUB=*/3);
5175 // Previous lower and upper bounds are obtained from the region
5178 buildDeclRefExpr(SemaRef, PrevLBDecl, PrevLBDecl->getType(), InitLoc);
5180 buildDeclRefExpr(SemaRef, PrevUBDecl, PrevUBDecl->getType(), InitLoc);
5184 // Build the iteration variable and its initialization before loop.
5188 VarDecl *IVDecl = buildVarDecl(SemaRef, InitLoc, RealVType, ".omp.iv");
5189 IV = buildDeclRefExpr(SemaRef, IVDecl, RealVType, InitLoc);
5190 Expr *RHS = (isOpenMPWorksharingDirective(DKind) ||
5191 isOpenMPTaskLoopDirective(DKind) ||
5192 isOpenMPDistributeDirective(DKind))
5194 : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
5195 Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS);
5196 Init = SemaRef.ActOnFinishFullExpr(Init.get());
5199 // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops.
5200 SourceLocation CondLoc;
5202 (isOpenMPWorksharingDirective(DKind) ||
5203 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
5204 ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get())
5205 : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(),
5206 NumIterations.get());
5208 // Loop increment (IV = IV + 1)
5209 SourceLocation IncLoc;
5211 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, IV.get(),
5212 SemaRef.ActOnIntegerConstant(IncLoc, 1).get());
5213 if (!Inc.isUsable())
5215 Inc = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, IV.get(), Inc.get());
5216 Inc = SemaRef.ActOnFinishFullExpr(Inc.get());
5217 if (!Inc.isUsable())
5220 // Increments for worksharing loops (LB = LB + ST; UB = UB + ST).
5221 // Used for directives with static scheduling.
5222 ExprResult NextLB, NextUB;
5223 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
5224 isOpenMPDistributeDirective(DKind)) {
5226 NextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, LB.get(), ST.get());
5227 if (!NextLB.isUsable())
5231 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, LB.get(), NextLB.get());
5232 NextLB = SemaRef.ActOnFinishFullExpr(NextLB.get());
5233 if (!NextLB.isUsable())
5236 NextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, UB.get(), ST.get());
5237 if (!NextUB.isUsable())
5241 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, UB.get(), NextUB.get());
5242 NextUB = SemaRef.ActOnFinishFullExpr(NextUB.get());
5243 if (!NextUB.isUsable())
5247 // Build updates and final values of the loop counters.
5248 bool HasErrors = false;
5249 Built.Counters.resize(NestedLoopCount);
5250 Built.Inits.resize(NestedLoopCount);
5251 Built.Updates.resize(NestedLoopCount);
5252 Built.Finals.resize(NestedLoopCount);
5253 SmallVector<Expr *, 4> LoopMultipliers;
5256 // Go from inner nested loop to outer.
5257 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
5258 LoopIterationSpace &IS = IterSpaces[Cnt];
5259 SourceLocation UpdLoc = IS.IncSrcRange.getBegin();
5260 // Build: Iter = (IV / Div) % IS.NumIters
5261 // where Div is product of previous iterations' IS.NumIters.
5263 if (Div.isUsable()) {
5265 SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Div, IV.get(), Div.get());
5268 assert((Cnt == (int)NestedLoopCount - 1) &&
5269 "unusable div expected on first iteration only");
5272 if (Cnt != 0 && Iter.isUsable())
5273 Iter = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Rem, Iter.get(),
5275 if (!Iter.isUsable()) {
5280 // Build update: IS.CounterVar(Private) = IS.Start + Iter * IS.Step
5281 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IS.CounterVar)->getDecl());
5282 auto *CounterVar = buildDeclRefExpr(SemaRef, VD, IS.CounterVar->getType(),
5283 IS.CounterVar->getExprLoc(),
5284 /*RefersToCapture=*/true);
5285 ExprResult Init = BuildCounterInit(SemaRef, CurScope, UpdLoc, CounterVar,
5286 IS.CounterInit, Captures);
5287 if (!Init.isUsable()) {
5291 ExprResult Update = BuildCounterUpdate(
5292 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, Iter,
5293 IS.CounterStep, IS.Subtract, &Captures);
5294 if (!Update.isUsable()) {
5299 // Build final: IS.CounterVar = IS.Start + IS.NumIters * IS.Step
5300 ExprResult Final = BuildCounterUpdate(
5301 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit,
5302 IS.NumIterations, IS.CounterStep, IS.Subtract, &Captures);
5303 if (!Final.isUsable()) {
5308 // Build Div for the next iteration: Div <- Div * IS.NumIters
5311 Div = IS.NumIterations;
5313 Div = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Mul, Div.get(),
5316 // Add parentheses (for debugging purposes only).
5318 Div = tryBuildCapture(SemaRef, Div.get(), Captures);
5319 if (!Div.isUsable()) {
5323 LoopMultipliers.push_back(Div.get());
5325 if (!Update.isUsable() || !Final.isUsable()) {
5330 Built.Counters[Cnt] = IS.CounterVar;
5331 Built.PrivateCounters[Cnt] = IS.PrivateCounterVar;
5332 Built.Inits[Cnt] = Init.get();
5333 Built.Updates[Cnt] = Update.get();
5334 Built.Finals[Cnt] = Final.get();
5342 Built.IterationVarRef = IV.get();
5343 Built.LastIteration = LastIteration.get();
5344 Built.NumIterations = NumIterations.get();
5345 Built.CalcLastIteration =
5346 SemaRef.ActOnFinishFullExpr(CalcLastIteration.get()).get();
5347 Built.PreCond = PreCond.get();
5348 Built.PreInits = buildPreInits(C, Captures);
5349 Built.Cond = Cond.get();
5350 Built.Init = Init.get();
5351 Built.Inc = Inc.get();
5352 Built.LB = LB.get();
5353 Built.UB = UB.get();
5354 Built.IL = IL.get();
5355 Built.ST = ST.get();
5356 Built.EUB = EUB.get();
5357 Built.NLB = NextLB.get();
5358 Built.NUB = NextUB.get();
5359 Built.PrevLB = PrevLB.get();
5360 Built.PrevUB = PrevUB.get();
5362 Expr *CounterVal = SemaRef.DefaultLvalueConversion(IV.get()).get();
5363 // Fill data for doacross depend clauses.
5364 for (auto Pair : DSA.getDoacrossDependClauses()) {
5365 if (Pair.first->getDependencyKind() == OMPC_DEPEND_source)
5366 Pair.first->setCounterValue(CounterVal);
5368 if (NestedLoopCount != Pair.second.size() ||
5369 NestedLoopCount != LoopMultipliers.size() + 1) {
5370 // Erroneous case - clause has some problems.
5371 Pair.first->setCounterValue(CounterVal);
5374 assert(Pair.first->getDependencyKind() == OMPC_DEPEND_sink);
5375 auto I = Pair.second.rbegin();
5376 auto IS = IterSpaces.rbegin();
5377 auto ILM = LoopMultipliers.rbegin();
5378 Expr *UpCounterVal = CounterVal;
5379 Expr *Multiplier = nullptr;
5380 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
5382 assert(IS->CounterStep);
5383 Expr *NormalizedOffset =
5385 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Div,
5386 I->first, IS->CounterStep)
5391 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Mul,
5392 NormalizedOffset, Multiplier)
5395 assert(I->second == OO_Plus || I->second == OO_Minus);
5396 BinaryOperatorKind BOK = (I->second == OO_Plus) ? BO_Add : BO_Sub;
5398 SemaRef.BuildBinOp(CurScope, I->first->getExprLoc(), BOK,
5399 UpCounterVal, NormalizedOffset).get();
5406 Pair.first->setCounterValue(UpCounterVal);
5410 return NestedLoopCount;
5413 static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) {
5414 auto CollapseClauses =
5415 OMPExecutableDirective::getClausesOfKind<OMPCollapseClause>(Clauses);
5416 if (CollapseClauses.begin() != CollapseClauses.end())
5417 return (*CollapseClauses.begin())->getNumForLoops();
5421 static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) {
5422 auto OrderedClauses =
5423 OMPExecutableDirective::getClausesOfKind<OMPOrderedClause>(Clauses);
5424 if (OrderedClauses.begin() != OrderedClauses.end())
5425 return (*OrderedClauses.begin())->getNumForLoops();
5429 static bool checkSimdlenSafelenSpecified(Sema &S,
5430 const ArrayRef<OMPClause *> Clauses) {
5431 OMPSafelenClause *Safelen = nullptr;
5432 OMPSimdlenClause *Simdlen = nullptr;
5434 for (auto *Clause : Clauses) {
5435 if (Clause->getClauseKind() == OMPC_safelen)
5436 Safelen = cast<OMPSafelenClause>(Clause);
5437 else if (Clause->getClauseKind() == OMPC_simdlen)
5438 Simdlen = cast<OMPSimdlenClause>(Clause);
5439 if (Safelen && Simdlen)
5443 if (Simdlen && Safelen) {
5444 llvm::APSInt SimdlenRes, SafelenRes;
5445 auto SimdlenLength = Simdlen->getSimdlen();
5446 auto SafelenLength = Safelen->getSafelen();
5447 if (SimdlenLength->isValueDependent() || SimdlenLength->isTypeDependent() ||
5448 SimdlenLength->isInstantiationDependent() ||
5449 SimdlenLength->containsUnexpandedParameterPack())
5451 if (SafelenLength->isValueDependent() || SafelenLength->isTypeDependent() ||
5452 SafelenLength->isInstantiationDependent() ||
5453 SafelenLength->containsUnexpandedParameterPack())
5455 SimdlenLength->EvaluateAsInt(SimdlenRes, S.Context);
5456 SafelenLength->EvaluateAsInt(SafelenRes, S.Context);
5457 // OpenMP 4.5 [2.8.1, simd Construct, Restrictions]
5458 // If both simdlen and safelen clauses are specified, the value of the
5459 // simdlen parameter must be less than or equal to the value of the safelen
5461 if (SimdlenRes > SafelenRes) {
5462 S.Diag(SimdlenLength->getExprLoc(),
5463 diag::err_omp_wrong_simdlen_safelen_values)
5464 << SimdlenLength->getSourceRange() << SafelenLength->getSourceRange();
5471 StmtResult Sema::ActOnOpenMPSimdDirective(
5472 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5473 SourceLocation EndLoc,
5474 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5478 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5479 OMPLoopDirective::HelperExprs B;
5480 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5481 // define the nested loops number.
5482 unsigned NestedLoopCount = CheckOpenMPLoop(
5483 OMPD_simd, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
5484 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
5485 if (NestedLoopCount == 0)
5488 assert((CurContext->isDependentContext() || B.builtAll()) &&
5489 "omp simd loop exprs were not built");
5491 if (!CurContext->isDependentContext()) {
5492 // Finalize the clauses that need pre-built expressions for CodeGen.
5493 for (auto C : Clauses) {
5494 if (auto LC = dyn_cast<OMPLinearClause>(C))
5495 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5496 B.NumIterations, *this, CurScope,
5502 if (checkSimdlenSafelenSpecified(*this, Clauses))
5505 getCurFunction()->setHasBranchProtectedScope();
5506 return OMPSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
5510 StmtResult Sema::ActOnOpenMPForDirective(
5511 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5512 SourceLocation EndLoc,
5513 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5517 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5518 OMPLoopDirective::HelperExprs B;
5519 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5520 // define the nested loops number.
5521 unsigned NestedLoopCount = CheckOpenMPLoop(
5522 OMPD_for, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
5523 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
5524 if (NestedLoopCount == 0)
5527 assert((CurContext->isDependentContext() || B.builtAll()) &&
5528 "omp for loop exprs were not built");
5530 if (!CurContext->isDependentContext()) {
5531 // Finalize the clauses that need pre-built expressions for CodeGen.
5532 for (auto C : Clauses) {
5533 if (auto LC = dyn_cast<OMPLinearClause>(C))
5534 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5535 B.NumIterations, *this, CurScope,
5541 getCurFunction()->setHasBranchProtectedScope();
5542 return OMPForDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
5543 Clauses, AStmt, B, DSAStack->isCancelRegion());
5546 StmtResult Sema::ActOnOpenMPForSimdDirective(
5547 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5548 SourceLocation EndLoc,
5549 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5553 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5554 OMPLoopDirective::HelperExprs B;
5555 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5556 // define the nested loops number.
5557 unsigned NestedLoopCount =
5558 CheckOpenMPLoop(OMPD_for_simd, getCollapseNumberExpr(Clauses),
5559 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5560 VarsWithImplicitDSA, B);
5561 if (NestedLoopCount == 0)
5564 assert((CurContext->isDependentContext() || B.builtAll()) &&
5565 "omp for simd loop exprs were not built");
5567 if (!CurContext->isDependentContext()) {
5568 // Finalize the clauses that need pre-built expressions for CodeGen.
5569 for (auto C : Clauses) {
5570 if (auto LC = dyn_cast<OMPLinearClause>(C))
5571 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5572 B.NumIterations, *this, CurScope,
5578 if (checkSimdlenSafelenSpecified(*this, Clauses))
5581 getCurFunction()->setHasBranchProtectedScope();
5582 return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
5586 StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
5588 SourceLocation StartLoc,
5589 SourceLocation EndLoc) {
5593 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5594 auto BaseStmt = AStmt;
5595 while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
5596 BaseStmt = CS->getCapturedStmt();
5597 if (auto C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
5598 auto S = C->children();
5599 if (S.begin() == S.end())
5601 // All associated statements must be '#pragma omp section' except for
5603 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
5604 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
5606 Diag(SectionStmt->getLocStart(),
5607 diag::err_omp_sections_substmt_not_section);
5610 cast<OMPSectionDirective>(SectionStmt)
5611 ->setHasCancel(DSAStack->isCancelRegion());
5614 Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt);
5618 getCurFunction()->setHasBranchProtectedScope();
5620 return OMPSectionsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5621 DSAStack->isCancelRegion());
5624 StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
5625 SourceLocation StartLoc,
5626 SourceLocation EndLoc) {
5630 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5632 getCurFunction()->setHasBranchProtectedScope();
5633 DSAStack->setParentCancelRegion(DSAStack->isCancelRegion());
5635 return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt,
5636 DSAStack->isCancelRegion());
5639 StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
5641 SourceLocation StartLoc,
5642 SourceLocation EndLoc) {
5646 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5648 getCurFunction()->setHasBranchProtectedScope();
5650 // OpenMP [2.7.3, single Construct, Restrictions]
5651 // The copyprivate clause must not be used with the nowait clause.
5652 OMPClause *Nowait = nullptr;
5653 OMPClause *Copyprivate = nullptr;
5654 for (auto *Clause : Clauses) {
5655 if (Clause->getClauseKind() == OMPC_nowait)
5657 else if (Clause->getClauseKind() == OMPC_copyprivate)
5658 Copyprivate = Clause;
5659 if (Copyprivate && Nowait) {
5660 Diag(Copyprivate->getLocStart(),
5661 diag::err_omp_single_copyprivate_with_nowait);
5662 Diag(Nowait->getLocStart(), diag::note_omp_nowait_clause_here);
5667 return OMPSingleDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5670 StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
5671 SourceLocation StartLoc,
5672 SourceLocation EndLoc) {
5676 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5678 getCurFunction()->setHasBranchProtectedScope();
5680 return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt);
5683 StmtResult Sema::ActOnOpenMPCriticalDirective(
5684 const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses,
5685 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
5689 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5691 bool ErrorFound = false;
5693 SourceLocation HintLoc;
5694 bool DependentHint = false;
5695 for (auto *C : Clauses) {
5696 if (C->getClauseKind() == OMPC_hint) {
5697 if (!DirName.getName()) {
5698 Diag(C->getLocStart(), diag::err_omp_hint_clause_no_name);
5701 Expr *E = cast<OMPHintClause>(C)->getHint();
5702 if (E->isTypeDependent() || E->isValueDependent() ||
5703 E->isInstantiationDependent())
5704 DependentHint = true;
5706 Hint = E->EvaluateKnownConstInt(Context);
5707 HintLoc = C->getLocStart();
5713 auto Pair = DSAStack->getCriticalWithHint(DirName);
5714 if (Pair.first && DirName.getName() && !DependentHint) {
5715 if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {
5716 Diag(StartLoc, diag::err_omp_critical_with_hint);
5717 if (HintLoc.isValid()) {
5718 Diag(HintLoc, diag::note_omp_critical_hint_here)
5719 << 0 << Hint.toString(/*Radix=*/10, /*Signed=*/false);
5721 Diag(StartLoc, diag::note_omp_critical_no_hint) << 0;
5722 if (auto *C = Pair.first->getSingleClause<OMPHintClause>()) {
5723 Diag(C->getLocStart(), diag::note_omp_critical_hint_here)
5725 << C->getHint()->EvaluateKnownConstInt(Context).toString(
5726 /*Radix=*/10, /*Signed=*/false);
5728 Diag(Pair.first->getLocStart(), diag::note_omp_critical_no_hint) << 1;
5732 getCurFunction()->setHasBranchProtectedScope();
5734 auto *Dir = OMPCriticalDirective::Create(Context, DirName, StartLoc, EndLoc,
5736 if (!Pair.first && DirName.getName() && !DependentHint)
5737 DSAStack->addCriticalWithHint(Dir, Hint);
5741 StmtResult Sema::ActOnOpenMPParallelForDirective(
5742 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5743 SourceLocation EndLoc,
5744 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5748 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5749 // 1.2.2 OpenMP Language Terminology
5750 // Structured block - An executable statement with a single entry at the
5751 // top and a single exit at the bottom.
5752 // The point of exit cannot be a branch out of the structured block.
5753 // longjmp() and throw() must not violate the entry/exit criteria.
5754 CS->getCapturedDecl()->setNothrow();
5756 OMPLoopDirective::HelperExprs B;
5757 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5758 // define the nested loops number.
5759 unsigned NestedLoopCount =
5760 CheckOpenMPLoop(OMPD_parallel_for, getCollapseNumberExpr(Clauses),
5761 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5762 VarsWithImplicitDSA, B);
5763 if (NestedLoopCount == 0)
5766 assert((CurContext->isDependentContext() || B.builtAll()) &&
5767 "omp parallel for loop exprs were not built");
5769 if (!CurContext->isDependentContext()) {
5770 // Finalize the clauses that need pre-built expressions for CodeGen.
5771 for (auto C : Clauses) {
5772 if (auto LC = dyn_cast<OMPLinearClause>(C))
5773 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5774 B.NumIterations, *this, CurScope,
5780 getCurFunction()->setHasBranchProtectedScope();
5781 return OMPParallelForDirective::Create(Context, StartLoc, EndLoc,
5782 NestedLoopCount, Clauses, AStmt, B,
5783 DSAStack->isCancelRegion());
5786 StmtResult Sema::ActOnOpenMPParallelForSimdDirective(
5787 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5788 SourceLocation EndLoc,
5789 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5793 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5794 // 1.2.2 OpenMP Language Terminology
5795 // Structured block - An executable statement with a single entry at the
5796 // top and a single exit at the bottom.
5797 // The point of exit cannot be a branch out of the structured block.
5798 // longjmp() and throw() must not violate the entry/exit criteria.
5799 CS->getCapturedDecl()->setNothrow();
5801 OMPLoopDirective::HelperExprs B;
5802 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5803 // define the nested loops number.
5804 unsigned NestedLoopCount =
5805 CheckOpenMPLoop(OMPD_parallel_for_simd, getCollapseNumberExpr(Clauses),
5806 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5807 VarsWithImplicitDSA, B);
5808 if (NestedLoopCount == 0)
5811 if (!CurContext->isDependentContext()) {
5812 // Finalize the clauses that need pre-built expressions for CodeGen.
5813 for (auto C : Clauses) {
5814 if (auto LC = dyn_cast<OMPLinearClause>(C))
5815 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5816 B.NumIterations, *this, CurScope,
5822 if (checkSimdlenSafelenSpecified(*this, Clauses))
5825 getCurFunction()->setHasBranchProtectedScope();
5826 return OMPParallelForSimdDirective::Create(
5827 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
5831 Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
5832 Stmt *AStmt, SourceLocation StartLoc,
5833 SourceLocation EndLoc) {
5837 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5838 auto BaseStmt = AStmt;
5839 while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
5840 BaseStmt = CS->getCapturedStmt();
5841 if (auto C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
5842 auto S = C->children();
5843 if (S.begin() == S.end())
5845 // All associated statements must be '#pragma omp section' except for
5847 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
5848 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
5850 Diag(SectionStmt->getLocStart(),
5851 diag::err_omp_parallel_sections_substmt_not_section);
5854 cast<OMPSectionDirective>(SectionStmt)
5855 ->setHasCancel(DSAStack->isCancelRegion());
5858 Diag(AStmt->getLocStart(),
5859 diag::err_omp_parallel_sections_not_compound_stmt);
5863 getCurFunction()->setHasBranchProtectedScope();
5865 return OMPParallelSectionsDirective::Create(
5866 Context, StartLoc, EndLoc, Clauses, AStmt, DSAStack->isCancelRegion());
5869 StmtResult Sema::ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
5870 Stmt *AStmt, SourceLocation StartLoc,
5871 SourceLocation EndLoc) {
5875 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5876 // 1.2.2 OpenMP Language Terminology
5877 // Structured block - An executable statement with a single entry at the
5878 // top and a single exit at the bottom.
5879 // The point of exit cannot be a branch out of the structured block.
5880 // longjmp() and throw() must not violate the entry/exit criteria.
5881 CS->getCapturedDecl()->setNothrow();
5883 getCurFunction()->setHasBranchProtectedScope();
5885 return OMPTaskDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5886 DSAStack->isCancelRegion());
5889 StmtResult Sema::ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
5890 SourceLocation EndLoc) {
5891 return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc);
5894 StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
5895 SourceLocation EndLoc) {
5896 return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
5899 StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
5900 SourceLocation EndLoc) {
5901 return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc);
5904 StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt,
5905 SourceLocation StartLoc,
5906 SourceLocation EndLoc) {
5910 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5912 getCurFunction()->setHasBranchProtectedScope();
5914 return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt);
5917 StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
5918 SourceLocation StartLoc,
5919 SourceLocation EndLoc) {
5920 assert(Clauses.size() <= 1 && "Extra clauses in flush directive");
5921 return OMPFlushDirective::Create(Context, StartLoc, EndLoc, Clauses);
5924 StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
5926 SourceLocation StartLoc,
5927 SourceLocation EndLoc) {
5928 OMPClause *DependFound = nullptr;
5929 OMPClause *DependSourceClause = nullptr;
5930 OMPClause *DependSinkClause = nullptr;
5931 bool ErrorFound = false;
5932 OMPThreadsClause *TC = nullptr;
5933 OMPSIMDClause *SC = nullptr;
5934 for (auto *C : Clauses) {
5935 if (auto *DC = dyn_cast<OMPDependClause>(C)) {
5937 if (DC->getDependencyKind() == OMPC_DEPEND_source) {
5938 if (DependSourceClause) {
5939 Diag(C->getLocStart(), diag::err_omp_more_one_clause)
5940 << getOpenMPDirectiveName(OMPD_ordered)
5941 << getOpenMPClauseName(OMPC_depend) << 2;
5944 DependSourceClause = C;
5945 if (DependSinkClause) {
5946 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
5950 } else if (DC->getDependencyKind() == OMPC_DEPEND_sink) {
5951 if (DependSourceClause) {
5952 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
5956 DependSinkClause = C;
5958 } else if (C->getClauseKind() == OMPC_threads)
5959 TC = cast<OMPThreadsClause>(C);
5960 else if (C->getClauseKind() == OMPC_simd)
5961 SC = cast<OMPSIMDClause>(C);
5963 if (!ErrorFound && !SC &&
5964 isOpenMPSimdDirective(DSAStack->getParentDirective())) {
5965 // OpenMP [2.8.1,simd Construct, Restrictions]
5966 // An ordered construct with the simd clause is the only OpenMP construct
5967 // that can appear in the simd region.
5968 Diag(StartLoc, diag::err_omp_prohibited_region_simd);
5970 } else if (DependFound && (TC || SC)) {
5971 Diag(DependFound->getLocStart(), diag::err_omp_depend_clause_thread_simd)
5972 << getOpenMPClauseName(TC ? TC->getClauseKind() : SC->getClauseKind());
5974 } else if (DependFound && !DSAStack->getParentOrderedRegionParam()) {
5975 Diag(DependFound->getLocStart(),
5976 diag::err_omp_ordered_directive_without_param);
5978 } else if (TC || Clauses.empty()) {
5979 if (auto *Param = DSAStack->getParentOrderedRegionParam()) {
5980 SourceLocation ErrLoc = TC ? TC->getLocStart() : StartLoc;
5981 Diag(ErrLoc, diag::err_omp_ordered_directive_with_param)
5983 Diag(Param->getLocStart(), diag::note_omp_ordered_param);
5987 if ((!AStmt && !DependFound) || ErrorFound)
5991 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5993 getCurFunction()->setHasBranchProtectedScope();
5996 return OMPOrderedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6000 /// \brief Helper class for checking expression in 'omp atomic [update]'
6002 class OpenMPAtomicUpdateChecker {
6003 /// \brief Error results for atomic update expressions.
6004 enum ExprAnalysisErrorCode {
6005 /// \brief A statement is not an expression statement.
6007 /// \brief Expression is not builtin binary or unary operation.
6008 NotABinaryOrUnaryExpression,
6009 /// \brief Unary operation is not post-/pre- increment/decrement operation.
6010 NotAnUnaryIncDecExpression,
6011 /// \brief An expression is not of scalar type.
6013 /// \brief A binary operation is not an assignment operation.
6015 /// \brief RHS part of the binary operation is not a binary expression.
6016 NotABinaryExpression,
6017 /// \brief RHS part is not additive/multiplicative/shift/biwise binary
6020 /// \brief RHS binary operation does not have reference to the updated LHS
6022 NotAnUpdateExpression,
6023 /// \brief No errors is found.
6026 /// \brief Reference to Sema.
6028 /// \brief A location for note diagnostics (when error is found).
6029 SourceLocation NoteLoc;
6030 /// \brief 'x' lvalue part of the source atomic expression.
6032 /// \brief 'expr' rvalue part of the source atomic expression.
6034 /// \brief Helper expression of the form
6035 /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
6036 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
6038 /// \brief Is 'x' a LHS in a RHS part of full update expression. It is
6039 /// important for non-associative operations.
6040 bool IsXLHSInRHSPart;
6041 BinaryOperatorKind Op;
6042 SourceLocation OpLoc;
6043 /// \brief true if the source expression is a postfix unary operation, false
6044 /// if it is a prefix unary operation.
6045 bool IsPostfixUpdate;
6048 OpenMPAtomicUpdateChecker(Sema &SemaRef)
6049 : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr),
6050 IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {}
6051 /// \brief Check specified statement that it is suitable for 'atomic update'
6052 /// constructs and extract 'x', 'expr' and Operation from the original
6053 /// expression. If DiagId and NoteId == 0, then only check is performed
6054 /// without error notification.
6055 /// \param DiagId Diagnostic which should be emitted if error is found.
6056 /// \param NoteId Diagnostic note for the main error message.
6057 /// \return true if statement is not an update expression, false otherwise.
6058 bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0);
6059 /// \brief Return the 'x' lvalue part of the source atomic expression.
6060 Expr *getX() const { return X; }
6061 /// \brief Return the 'expr' rvalue part of the source atomic expression.
6062 Expr *getExpr() const { return E; }
6063 /// \brief Return the update expression used in calculation of the updated
6064 /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
6065 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
6066 Expr *getUpdateExpr() const { return UpdateExpr; }
6067 /// \brief Return true if 'x' is LHS in RHS part of full update expression,
6068 /// false otherwise.
6069 bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
6071 /// \brief true if the source expression is a postfix unary operation, false
6072 /// if it is a prefix unary operation.
6073 bool isPostfixUpdate() const { return IsPostfixUpdate; }
6076 bool checkBinaryOperation(BinaryOperator *AtomicBinOp, unsigned DiagId = 0,
6077 unsigned NoteId = 0);
6081 bool OpenMPAtomicUpdateChecker::checkBinaryOperation(
6082 BinaryOperator *AtomicBinOp, unsigned DiagId, unsigned NoteId) {
6083 ExprAnalysisErrorCode ErrorFound = NoError;
6084 SourceLocation ErrorLoc, NoteLoc;
6085 SourceRange ErrorRange, NoteRange;
6086 // Allowed constructs are:
6087 // x = x binop expr;
6088 // x = expr binop x;
6089 if (AtomicBinOp->getOpcode() == BO_Assign) {
6090 X = AtomicBinOp->getLHS();
6091 if (auto *AtomicInnerBinOp = dyn_cast<BinaryOperator>(
6092 AtomicBinOp->getRHS()->IgnoreParenImpCasts())) {
6093 if (AtomicInnerBinOp->isMultiplicativeOp() ||
6094 AtomicInnerBinOp->isAdditiveOp() || AtomicInnerBinOp->isShiftOp() ||
6095 AtomicInnerBinOp->isBitwiseOp()) {
6096 Op = AtomicInnerBinOp->getOpcode();
6097 OpLoc = AtomicInnerBinOp->getOperatorLoc();
6098 auto *LHS = AtomicInnerBinOp->getLHS();
6099 auto *RHS = AtomicInnerBinOp->getRHS();
6100 llvm::FoldingSetNodeID XId, LHSId, RHSId;
6101 X->IgnoreParenImpCasts()->Profile(XId, SemaRef.getASTContext(),
6102 /*Canonical=*/true);
6103 LHS->IgnoreParenImpCasts()->Profile(LHSId, SemaRef.getASTContext(),
6104 /*Canonical=*/true);
6105 RHS->IgnoreParenImpCasts()->Profile(RHSId, SemaRef.getASTContext(),
6106 /*Canonical=*/true);
6109 IsXLHSInRHSPart = true;
6110 } else if (XId == RHSId) {
6112 IsXLHSInRHSPart = false;
6114 ErrorLoc = AtomicInnerBinOp->getExprLoc();
6115 ErrorRange = AtomicInnerBinOp->getSourceRange();
6116 NoteLoc = X->getExprLoc();
6117 NoteRange = X->getSourceRange();
6118 ErrorFound = NotAnUpdateExpression;
6121 ErrorLoc = AtomicInnerBinOp->getExprLoc();
6122 ErrorRange = AtomicInnerBinOp->getSourceRange();
6123 NoteLoc = AtomicInnerBinOp->getOperatorLoc();
6124 NoteRange = SourceRange(NoteLoc, NoteLoc);
6125 ErrorFound = NotABinaryOperator;
6128 NoteLoc = ErrorLoc = AtomicBinOp->getRHS()->getExprLoc();
6129 NoteRange = ErrorRange = AtomicBinOp->getRHS()->getSourceRange();
6130 ErrorFound = NotABinaryExpression;
6133 ErrorLoc = AtomicBinOp->getExprLoc();
6134 ErrorRange = AtomicBinOp->getSourceRange();
6135 NoteLoc = AtomicBinOp->getOperatorLoc();
6136 NoteRange = SourceRange(NoteLoc, NoteLoc);
6137 ErrorFound = NotAnAssignmentOp;
6139 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
6140 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
6141 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
6143 } else if (SemaRef.CurContext->isDependentContext())
6144 E = X = UpdateExpr = nullptr;
6145 return ErrorFound != NoError;
6148 bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
6150 ExprAnalysisErrorCode ErrorFound = NoError;
6151 SourceLocation ErrorLoc, NoteLoc;
6152 SourceRange ErrorRange, NoteRange;
6153 // Allowed constructs are:
6159 // x = x binop expr;
6160 // x = expr binop x;
6161 if (auto *AtomicBody = dyn_cast<Expr>(S)) {
6162 AtomicBody = AtomicBody->IgnoreParenImpCasts();
6163 if (AtomicBody->getType()->isScalarType() ||
6164 AtomicBody->isInstantiationDependent()) {
6165 if (auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>(
6166 AtomicBody->IgnoreParenImpCasts())) {
6167 // Check for Compound Assignment Operation
6168 Op = BinaryOperator::getOpForCompoundAssignment(
6169 AtomicCompAssignOp->getOpcode());
6170 OpLoc = AtomicCompAssignOp->getOperatorLoc();
6171 E = AtomicCompAssignOp->getRHS();
6172 X = AtomicCompAssignOp->getLHS();
6173 IsXLHSInRHSPart = true;
6174 } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>(
6175 AtomicBody->IgnoreParenImpCasts())) {
6176 // Check for Binary Operation
6177 if(checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
6179 } else if (auto *AtomicUnaryOp =
6180 dyn_cast<UnaryOperator>(AtomicBody->IgnoreParenImpCasts())) {
6181 // Check for Unary Operation
6182 if (AtomicUnaryOp->isIncrementDecrementOp()) {
6183 IsPostfixUpdate = AtomicUnaryOp->isPostfix();
6184 Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub;
6185 OpLoc = AtomicUnaryOp->getOperatorLoc();
6186 X = AtomicUnaryOp->getSubExpr();
6187 E = SemaRef.ActOnIntegerConstant(OpLoc, /*uint64_t Val=*/1).get();
6188 IsXLHSInRHSPart = true;
6190 ErrorFound = NotAnUnaryIncDecExpression;
6191 ErrorLoc = AtomicUnaryOp->getExprLoc();
6192 ErrorRange = AtomicUnaryOp->getSourceRange();
6193 NoteLoc = AtomicUnaryOp->getOperatorLoc();
6194 NoteRange = SourceRange(NoteLoc, NoteLoc);
6196 } else if (!AtomicBody->isInstantiationDependent()) {
6197 ErrorFound = NotABinaryOrUnaryExpression;
6198 NoteLoc = ErrorLoc = AtomicBody->getExprLoc();
6199 NoteRange = ErrorRange = AtomicBody->getSourceRange();
6202 ErrorFound = NotAScalarType;
6203 NoteLoc = ErrorLoc = AtomicBody->getLocStart();
6204 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6207 ErrorFound = NotAnExpression;
6208 NoteLoc = ErrorLoc = S->getLocStart();
6209 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6211 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
6212 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
6213 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
6215 } else if (SemaRef.CurContext->isDependentContext())
6216 E = X = UpdateExpr = nullptr;
6217 if (ErrorFound == NoError && E && X) {
6218 // Build an update expression of form 'OpaqueValueExpr(x) binop
6219 // OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop
6220 // OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression.
6221 auto *OVEX = new (SemaRef.getASTContext())
6222 OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue);
6223 auto *OVEExpr = new (SemaRef.getASTContext())
6224 OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue);
6226 SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr,
6227 IsXLHSInRHSPart ? OVEExpr : OVEX);
6228 if (Update.isInvalid())
6230 Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(),
6232 if (Update.isInvalid())
6234 UpdateExpr = Update.get();
6236 return ErrorFound != NoError;
6239 StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
6241 SourceLocation StartLoc,
6242 SourceLocation EndLoc) {
6246 auto CS = cast<CapturedStmt>(AStmt);
6247 // 1.2.2 OpenMP Language Terminology
6248 // Structured block - An executable statement with a single entry at the
6249 // top and a single exit at the bottom.
6250 // The point of exit cannot be a branch out of the structured block.
6251 // longjmp() and throw() must not violate the entry/exit criteria.
6252 OpenMPClauseKind AtomicKind = OMPC_unknown;
6253 SourceLocation AtomicKindLoc;
6254 for (auto *C : Clauses) {
6255 if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write ||
6256 C->getClauseKind() == OMPC_update ||
6257 C->getClauseKind() == OMPC_capture) {
6258 if (AtomicKind != OMPC_unknown) {
6259 Diag(C->getLocStart(), diag::err_omp_atomic_several_clauses)
6260 << SourceRange(C->getLocStart(), C->getLocEnd());
6261 Diag(AtomicKindLoc, diag::note_omp_atomic_previous_clause)
6262 << getOpenMPClauseName(AtomicKind);
6264 AtomicKind = C->getClauseKind();
6265 AtomicKindLoc = C->getLocStart();
6270 auto Body = CS->getCapturedStmt();
6271 if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
6272 Body = EWC->getSubExpr();
6278 bool IsXLHSInRHSPart = false;
6279 bool IsPostfixUpdate = false;
6280 // OpenMP [2.12.6, atomic Construct]
6281 // In the next expressions:
6282 // * x and v (as applicable) are both l-value expressions with scalar type.
6283 // * During the execution of an atomic region, multiple syntactic
6284 // occurrences of x must designate the same storage location.
6285 // * Neither of v and expr (as applicable) may access the storage location
6287 // * Neither of x and expr (as applicable) may access the storage location
6289 // * expr is an expression with scalar type.
6290 // * binop is one of +, *, -, /, &, ^, |, <<, or >>.
6291 // * binop, binop=, ++, and -- are not overloaded operators.
6292 // * The expression x binop expr must be numerically equivalent to x binop
6293 // (expr). This requirement is satisfied if the operators in expr have
6294 // precedence greater than binop, or by using parentheses around expr or
6295 // subexpressions of expr.
6296 // * The expression expr binop x must be numerically equivalent to (expr)
6297 // binop x. This requirement is satisfied if the operators in expr have
6298 // precedence equal to or greater than binop, or by using parentheses around
6299 // expr or subexpressions of expr.
6300 // * For forms that allow multiple occurrences of x, the number of times
6301 // that x is evaluated is unspecified.
6302 if (AtomicKind == OMPC_read) {
6309 } ErrorFound = NoError;
6310 SourceLocation ErrorLoc, NoteLoc;
6311 SourceRange ErrorRange, NoteRange;
6312 // If clause is read:
6314 if (auto AtomicBody = dyn_cast<Expr>(Body)) {
6316 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
6317 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
6318 X = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
6319 V = AtomicBinOp->getLHS()->IgnoreParenImpCasts();
6320 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
6321 (V->isInstantiationDependent() || V->getType()->isScalarType())) {
6322 if (!X->isLValue() || !V->isLValue()) {
6323 auto NotLValueExpr = X->isLValue() ? V : X;
6324 ErrorFound = NotAnLValue;
6325 ErrorLoc = AtomicBinOp->getExprLoc();
6326 ErrorRange = AtomicBinOp->getSourceRange();
6327 NoteLoc = NotLValueExpr->getExprLoc();
6328 NoteRange = NotLValueExpr->getSourceRange();
6330 } else if (!X->isInstantiationDependent() ||
6331 !V->isInstantiationDependent()) {
6332 auto NotScalarExpr =
6333 (X->isInstantiationDependent() || X->getType()->isScalarType())
6336 ErrorFound = NotAScalarType;
6337 ErrorLoc = AtomicBinOp->getExprLoc();
6338 ErrorRange = AtomicBinOp->getSourceRange();
6339 NoteLoc = NotScalarExpr->getExprLoc();
6340 NoteRange = NotScalarExpr->getSourceRange();
6342 } else if (!AtomicBody->isInstantiationDependent()) {
6343 ErrorFound = NotAnAssignmentOp;
6344 ErrorLoc = AtomicBody->getExprLoc();
6345 ErrorRange = AtomicBody->getSourceRange();
6346 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
6347 : AtomicBody->getExprLoc();
6348 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
6349 : AtomicBody->getSourceRange();
6352 ErrorFound = NotAnExpression;
6353 NoteLoc = ErrorLoc = Body->getLocStart();
6354 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6356 if (ErrorFound != NoError) {
6357 Diag(ErrorLoc, diag::err_omp_atomic_read_not_expression_statement)
6359 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
6362 } else if (CurContext->isDependentContext())
6364 } else if (AtomicKind == OMPC_write) {
6371 } ErrorFound = NoError;
6372 SourceLocation ErrorLoc, NoteLoc;
6373 SourceRange ErrorRange, NoteRange;
6374 // If clause is write:
6376 if (auto AtomicBody = dyn_cast<Expr>(Body)) {
6378 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
6379 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
6380 X = AtomicBinOp->getLHS();
6381 E = AtomicBinOp->getRHS();
6382 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
6383 (E->isInstantiationDependent() || E->getType()->isScalarType())) {
6384 if (!X->isLValue()) {
6385 ErrorFound = NotAnLValue;
6386 ErrorLoc = AtomicBinOp->getExprLoc();
6387 ErrorRange = AtomicBinOp->getSourceRange();
6388 NoteLoc = X->getExprLoc();
6389 NoteRange = X->getSourceRange();
6391 } else if (!X->isInstantiationDependent() ||
6392 !E->isInstantiationDependent()) {
6393 auto NotScalarExpr =
6394 (X->isInstantiationDependent() || X->getType()->isScalarType())
6397 ErrorFound = NotAScalarType;
6398 ErrorLoc = AtomicBinOp->getExprLoc();
6399 ErrorRange = AtomicBinOp->getSourceRange();
6400 NoteLoc = NotScalarExpr->getExprLoc();
6401 NoteRange = NotScalarExpr->getSourceRange();
6403 } else if (!AtomicBody->isInstantiationDependent()) {
6404 ErrorFound = NotAnAssignmentOp;
6405 ErrorLoc = AtomicBody->getExprLoc();
6406 ErrorRange = AtomicBody->getSourceRange();
6407 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
6408 : AtomicBody->getExprLoc();
6409 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
6410 : AtomicBody->getSourceRange();
6413 ErrorFound = NotAnExpression;
6414 NoteLoc = ErrorLoc = Body->getLocStart();
6415 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
6417 if (ErrorFound != NoError) {
6418 Diag(ErrorLoc, diag::err_omp_atomic_write_not_expression_statement)
6420 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
6423 } else if (CurContext->isDependentContext())
6425 } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {
6426 // If clause is update:
6432 // x = x binop expr;
6433 // x = expr binop x;
6434 OpenMPAtomicUpdateChecker Checker(*this);
6435 if (Checker.checkStatement(
6436 Body, (AtomicKind == OMPC_update)
6437 ? diag::err_omp_atomic_update_not_expression_statement
6438 : diag::err_omp_atomic_not_expression_statement,
6439 diag::note_omp_atomic_update))
6441 if (!CurContext->isDependentContext()) {
6442 E = Checker.getExpr();
6444 UE = Checker.getUpdateExpr();
6445 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6447 } else if (AtomicKind == OMPC_capture) {
6450 NotACompoundStatement,
6451 NotTwoSubstatements,
6452 NotASpecificExpression,
6454 } ErrorFound = NoError;
6455 SourceLocation ErrorLoc, NoteLoc;
6456 SourceRange ErrorRange, NoteRange;
6457 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
6458 // If clause is a capture:
6463 // v = x binop= expr;
6464 // v = x = x binop expr;
6465 // v = x = expr binop x;
6467 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
6468 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
6469 V = AtomicBinOp->getLHS();
6470 Body = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
6471 OpenMPAtomicUpdateChecker Checker(*this);
6472 if (Checker.checkStatement(
6473 Body, diag::err_omp_atomic_capture_not_expression_statement,
6474 diag::note_omp_atomic_update))
6476 E = Checker.getExpr();
6478 UE = Checker.getUpdateExpr();
6479 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6480 IsPostfixUpdate = Checker.isPostfixUpdate();
6481 } else if (!AtomicBody->isInstantiationDependent()) {
6482 ErrorLoc = AtomicBody->getExprLoc();
6483 ErrorRange = AtomicBody->getSourceRange();
6484 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
6485 : AtomicBody->getExprLoc();
6486 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
6487 : AtomicBody->getSourceRange();
6488 ErrorFound = NotAnAssignmentOp;
6490 if (ErrorFound != NoError) {
6491 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_expression_statement)
6493 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
6495 } else if (CurContext->isDependentContext()) {
6496 UE = V = E = X = nullptr;
6499 // If clause is a capture:
6500 // { v = x; x = expr; }
6505 // { v = x; x binop= expr; }
6506 // { v = x; x = x binop expr; }
6507 // { v = x; x = expr binop x; }
6512 // { x binop= expr; v = x; }
6513 // { x = x binop expr; v = x; }
6514 // { x = expr binop x; v = x; }
6515 if (auto *CS = dyn_cast<CompoundStmt>(Body)) {
6516 // Check that this is { expr1; expr2; }
6517 if (CS->size() == 2) {
6518 auto *First = CS->body_front();
6519 auto *Second = CS->body_back();
6520 if (auto *EWC = dyn_cast<ExprWithCleanups>(First))
6521 First = EWC->getSubExpr()->IgnoreParenImpCasts();
6522 if (auto *EWC = dyn_cast<ExprWithCleanups>(Second))
6523 Second = EWC->getSubExpr()->IgnoreParenImpCasts();
6524 // Need to find what subexpression is 'v' and what is 'x'.
6525 OpenMPAtomicUpdateChecker Checker(*this);
6526 bool IsUpdateExprFound = !Checker.checkStatement(Second);
6527 BinaryOperator *BinOp = nullptr;
6528 if (IsUpdateExprFound) {
6529 BinOp = dyn_cast<BinaryOperator>(First);
6530 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
6532 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
6537 // { v = x; x binop= expr; }
6538 // { v = x; x = x binop expr; }
6539 // { v = x; x = expr binop x; }
6540 // Check that the first expression has form v = x.
6541 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
6542 llvm::FoldingSetNodeID XId, PossibleXId;
6543 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
6544 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
6545 IsUpdateExprFound = XId == PossibleXId;
6546 if (IsUpdateExprFound) {
6547 V = BinOp->getLHS();
6549 E = Checker.getExpr();
6550 UE = Checker.getUpdateExpr();
6551 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6552 IsPostfixUpdate = true;
6555 if (!IsUpdateExprFound) {
6556 IsUpdateExprFound = !Checker.checkStatement(First);
6558 if (IsUpdateExprFound) {
6559 BinOp = dyn_cast<BinaryOperator>(Second);
6560 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
6562 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
6567 // { x binop= expr; v = x; }
6568 // { x = x binop expr; v = x; }
6569 // { x = expr binop x; v = x; }
6570 // Check that the second expression has form v = x.
6571 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
6572 llvm::FoldingSetNodeID XId, PossibleXId;
6573 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
6574 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
6575 IsUpdateExprFound = XId == PossibleXId;
6576 if (IsUpdateExprFound) {
6577 V = BinOp->getLHS();
6579 E = Checker.getExpr();
6580 UE = Checker.getUpdateExpr();
6581 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
6582 IsPostfixUpdate = false;
6586 if (!IsUpdateExprFound) {
6587 // { v = x; x = expr; }
6588 auto *FirstExpr = dyn_cast<Expr>(First);
6589 auto *SecondExpr = dyn_cast<Expr>(Second);
6590 if (!FirstExpr || !SecondExpr ||
6591 !(FirstExpr->isInstantiationDependent() ||
6592 SecondExpr->isInstantiationDependent())) {
6593 auto *FirstBinOp = dyn_cast<BinaryOperator>(First);
6594 if (!FirstBinOp || FirstBinOp->getOpcode() != BO_Assign) {
6595 ErrorFound = NotAnAssignmentOp;
6596 NoteLoc = ErrorLoc = FirstBinOp ? FirstBinOp->getOperatorLoc()
6597 : First->getLocStart();
6598 NoteRange = ErrorRange = FirstBinOp
6599 ? FirstBinOp->getSourceRange()
6600 : SourceRange(ErrorLoc, ErrorLoc);
6602 auto *SecondBinOp = dyn_cast<BinaryOperator>(Second);
6603 if (!SecondBinOp || SecondBinOp->getOpcode() != BO_Assign) {
6604 ErrorFound = NotAnAssignmentOp;
6605 NoteLoc = ErrorLoc = SecondBinOp
6606 ? SecondBinOp->getOperatorLoc()
6607 : Second->getLocStart();
6608 NoteRange = ErrorRange =
6609 SecondBinOp ? SecondBinOp->getSourceRange()
6610 : SourceRange(ErrorLoc, ErrorLoc);
6612 auto *PossibleXRHSInFirst =
6613 FirstBinOp->getRHS()->IgnoreParenImpCasts();
6614 auto *PossibleXLHSInSecond =
6615 SecondBinOp->getLHS()->IgnoreParenImpCasts();
6616 llvm::FoldingSetNodeID X1Id, X2Id;
6617 PossibleXRHSInFirst->Profile(X1Id, Context,
6618 /*Canonical=*/true);
6619 PossibleXLHSInSecond->Profile(X2Id, Context,
6620 /*Canonical=*/true);
6621 IsUpdateExprFound = X1Id == X2Id;
6622 if (IsUpdateExprFound) {
6623 V = FirstBinOp->getLHS();
6624 X = SecondBinOp->getLHS();
6625 E = SecondBinOp->getRHS();
6627 IsXLHSInRHSPart = false;
6628 IsPostfixUpdate = true;
6630 ErrorFound = NotASpecificExpression;
6631 ErrorLoc = FirstBinOp->getExprLoc();
6632 ErrorRange = FirstBinOp->getSourceRange();
6633 NoteLoc = SecondBinOp->getLHS()->getExprLoc();
6634 NoteRange = SecondBinOp->getRHS()->getSourceRange();
6641 NoteLoc = ErrorLoc = Body->getLocStart();
6642 NoteRange = ErrorRange =
6643 SourceRange(Body->getLocStart(), Body->getLocStart());
6644 ErrorFound = NotTwoSubstatements;
6647 NoteLoc = ErrorLoc = Body->getLocStart();
6648 NoteRange = ErrorRange =
6649 SourceRange(Body->getLocStart(), Body->getLocStart());
6650 ErrorFound = NotACompoundStatement;
6652 if (ErrorFound != NoError) {
6653 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement)
6655 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
6657 } else if (CurContext->isDependentContext()) {
6658 UE = V = E = X = nullptr;
6663 getCurFunction()->setHasBranchProtectedScope();
6665 return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
6666 X, V, E, UE, IsXLHSInRHSPart,
6670 StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
6672 SourceLocation StartLoc,
6673 SourceLocation EndLoc) {
6677 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6678 // 1.2.2 OpenMP Language Terminology
6679 // Structured block - An executable statement with a single entry at the
6680 // top and a single exit at the bottom.
6681 // The point of exit cannot be a branch out of the structured block.
6682 // longjmp() and throw() must not violate the entry/exit criteria.
6683 CS->getCapturedDecl()->setNothrow();
6685 // OpenMP [2.16, Nesting of Regions]
6686 // If specified, a teams construct must be contained within a target
6687 // construct. That target construct must contain no statements or directives
6688 // outside of the teams construct.
6689 if (DSAStack->hasInnerTeamsRegion()) {
6690 auto S = AStmt->IgnoreContainers(/*IgnoreCaptured*/ true);
6691 bool OMPTeamsFound = true;
6692 if (auto *CS = dyn_cast<CompoundStmt>(S)) {
6693 auto I = CS->body_begin();
6694 while (I != CS->body_end()) {
6695 auto OED = dyn_cast<OMPExecutableDirective>(*I);
6696 if (!OED || !isOpenMPTeamsDirective(OED->getDirectiveKind())) {
6697 OMPTeamsFound = false;
6702 assert(I != CS->body_end() && "Not found statement");
6705 auto *OED = dyn_cast<OMPExecutableDirective>(S);
6706 OMPTeamsFound = OED && isOpenMPTeamsDirective(OED->getDirectiveKind());
6708 if (!OMPTeamsFound) {
6709 Diag(StartLoc, diag::err_omp_target_contains_not_only_teams);
6710 Diag(DSAStack->getInnerTeamsRegionLoc(),
6711 diag::note_omp_nested_teams_construct_here);
6712 Diag(S->getLocStart(), diag::note_omp_nested_statement_here)
6713 << isa<OMPExecutableDirective>(S);
6718 getCurFunction()->setHasBranchProtectedScope();
6720 return OMPTargetDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6724 Sema::ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
6725 Stmt *AStmt, SourceLocation StartLoc,
6726 SourceLocation EndLoc) {
6730 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6731 // 1.2.2 OpenMP Language Terminology
6732 // Structured block - An executable statement with a single entry at the
6733 // top and a single exit at the bottom.
6734 // The point of exit cannot be a branch out of the structured block.
6735 // longjmp() and throw() must not violate the entry/exit criteria.
6736 CS->getCapturedDecl()->setNothrow();
6738 getCurFunction()->setHasBranchProtectedScope();
6740 return OMPTargetParallelDirective::Create(Context, StartLoc, EndLoc, Clauses,
6744 StmtResult Sema::ActOnOpenMPTargetParallelForDirective(
6745 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6746 SourceLocation EndLoc,
6747 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6751 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6752 // 1.2.2 OpenMP Language Terminology
6753 // Structured block - An executable statement with a single entry at the
6754 // top and a single exit at the bottom.
6755 // The point of exit cannot be a branch out of the structured block.
6756 // longjmp() and throw() must not violate the entry/exit criteria.
6757 CS->getCapturedDecl()->setNothrow();
6759 OMPLoopDirective::HelperExprs B;
6760 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6761 // define the nested loops number.
6762 unsigned NestedLoopCount =
6763 CheckOpenMPLoop(OMPD_target_parallel_for, getCollapseNumberExpr(Clauses),
6764 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
6765 VarsWithImplicitDSA, B);
6766 if (NestedLoopCount == 0)
6769 assert((CurContext->isDependentContext() || B.builtAll()) &&
6770 "omp target parallel for loop exprs were not built");
6772 if (!CurContext->isDependentContext()) {
6773 // Finalize the clauses that need pre-built expressions for CodeGen.
6774 for (auto C : Clauses) {
6775 if (auto LC = dyn_cast<OMPLinearClause>(C))
6776 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6777 B.NumIterations, *this, CurScope,
6783 getCurFunction()->setHasBranchProtectedScope();
6784 return OMPTargetParallelForDirective::Create(Context, StartLoc, EndLoc,
6785 NestedLoopCount, Clauses, AStmt,
6786 B, DSAStack->isCancelRegion());
6789 /// \brief Check for existence of a map clause in the list of clauses.
6790 static bool HasMapClause(ArrayRef<OMPClause *> Clauses) {
6791 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
6793 if (*I != nullptr && (*I)->getClauseKind() == OMPC_map) {
6801 StmtResult Sema::ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
6803 SourceLocation StartLoc,
6804 SourceLocation EndLoc) {
6808 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6810 // OpenMP [2.10.1, Restrictions, p. 97]
6811 // At least one map clause must appear on the directive.
6812 if (!HasMapClause(Clauses)) {
6813 Diag(StartLoc, diag::err_omp_no_map_for_directive) <<
6814 getOpenMPDirectiveName(OMPD_target_data);
6818 getCurFunction()->setHasBranchProtectedScope();
6820 return OMPTargetDataDirective::Create(Context, StartLoc, EndLoc, Clauses,
6825 Sema::ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
6826 SourceLocation StartLoc,
6827 SourceLocation EndLoc) {
6828 // OpenMP [2.10.2, Restrictions, p. 99]
6829 // At least one map clause must appear on the directive.
6830 if (!HasMapClause(Clauses)) {
6831 Diag(StartLoc, diag::err_omp_no_map_for_directive)
6832 << getOpenMPDirectiveName(OMPD_target_enter_data);
6836 return OMPTargetEnterDataDirective::Create(Context, StartLoc, EndLoc,
6841 Sema::ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
6842 SourceLocation StartLoc,
6843 SourceLocation EndLoc) {
6844 // OpenMP [2.10.3, Restrictions, p. 102]
6845 // At least one map clause must appear on the directive.
6846 if (!HasMapClause(Clauses)) {
6847 Diag(StartLoc, diag::err_omp_no_map_for_directive)
6848 << getOpenMPDirectiveName(OMPD_target_exit_data);
6852 return OMPTargetExitDataDirective::Create(Context, StartLoc, EndLoc, Clauses);
6855 StmtResult Sema::ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
6856 SourceLocation StartLoc,
6857 SourceLocation EndLoc) {
6858 bool seenMotionClause = false;
6859 for (auto *C : Clauses) {
6860 if (C->getClauseKind() == OMPC_to || C->getClauseKind() == OMPC_from)
6861 seenMotionClause = true;
6863 if (!seenMotionClause) {
6864 Diag(StartLoc, diag::err_omp_at_least_one_motion_clause_required);
6867 return OMPTargetUpdateDirective::Create(Context, StartLoc, EndLoc, Clauses);
6870 StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
6871 Stmt *AStmt, SourceLocation StartLoc,
6872 SourceLocation EndLoc) {
6876 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6877 // 1.2.2 OpenMP Language Terminology
6878 // Structured block - An executable statement with a single entry at the
6879 // top and a single exit at the bottom.
6880 // The point of exit cannot be a branch out of the structured block.
6881 // longjmp() and throw() must not violate the entry/exit criteria.
6882 CS->getCapturedDecl()->setNothrow();
6884 getCurFunction()->setHasBranchProtectedScope();
6886 return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6890 Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
6891 SourceLocation EndLoc,
6892 OpenMPDirectiveKind CancelRegion) {
6893 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
6894 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
6895 Diag(StartLoc, diag::err_omp_wrong_cancel_region)
6896 << getOpenMPDirectiveName(CancelRegion);
6899 if (DSAStack->isParentNowaitRegion()) {
6900 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0;
6903 if (DSAStack->isParentOrderedRegion()) {
6904 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0;
6907 return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc,
6911 StmtResult Sema::ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
6912 SourceLocation StartLoc,
6913 SourceLocation EndLoc,
6914 OpenMPDirectiveKind CancelRegion) {
6915 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
6916 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
6917 Diag(StartLoc, diag::err_omp_wrong_cancel_region)
6918 << getOpenMPDirectiveName(CancelRegion);
6921 if (DSAStack->isParentNowaitRegion()) {
6922 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1;
6925 if (DSAStack->isParentOrderedRegion()) {
6926 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1;
6929 DSAStack->setParentCancelRegion(/*Cancel=*/true);
6930 return OMPCancelDirective::Create(Context, StartLoc, EndLoc, Clauses,
6934 static bool checkGrainsizeNumTasksClauses(Sema &S,
6935 ArrayRef<OMPClause *> Clauses) {
6936 OMPClause *PrevClause = nullptr;
6937 bool ErrorFound = false;
6938 for (auto *C : Clauses) {
6939 if (C->getClauseKind() == OMPC_grainsize ||
6940 C->getClauseKind() == OMPC_num_tasks) {
6943 else if (PrevClause->getClauseKind() != C->getClauseKind()) {
6944 S.Diag(C->getLocStart(),
6945 diag::err_omp_grainsize_num_tasks_mutually_exclusive)
6946 << getOpenMPClauseName(C->getClauseKind())
6947 << getOpenMPClauseName(PrevClause->getClauseKind());
6948 S.Diag(PrevClause->getLocStart(),
6949 diag::note_omp_previous_grainsize_num_tasks)
6950 << getOpenMPClauseName(PrevClause->getClauseKind());
6958 StmtResult Sema::ActOnOpenMPTaskLoopDirective(
6959 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6960 SourceLocation EndLoc,
6961 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6965 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6966 OMPLoopDirective::HelperExprs B;
6967 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6968 // define the nested loops number.
6969 unsigned NestedLoopCount =
6970 CheckOpenMPLoop(OMPD_taskloop, getCollapseNumberExpr(Clauses),
6971 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
6972 VarsWithImplicitDSA, B);
6973 if (NestedLoopCount == 0)
6976 assert((CurContext->isDependentContext() || B.builtAll()) &&
6977 "omp for loop exprs were not built");
6979 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
6980 // The grainsize clause and num_tasks clause are mutually exclusive and may
6981 // not appear on the same taskloop directive.
6982 if (checkGrainsizeNumTasksClauses(*this, Clauses))
6985 getCurFunction()->setHasBranchProtectedScope();
6986 return OMPTaskLoopDirective::Create(Context, StartLoc, EndLoc,
6987 NestedLoopCount, Clauses, AStmt, B);
6990 StmtResult Sema::ActOnOpenMPTaskLoopSimdDirective(
6991 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6992 SourceLocation EndLoc,
6993 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6997 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6998 OMPLoopDirective::HelperExprs B;
6999 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
7000 // define the nested loops number.
7001 unsigned NestedLoopCount =
7002 CheckOpenMPLoop(OMPD_taskloop_simd, getCollapseNumberExpr(Clauses),
7003 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
7004 VarsWithImplicitDSA, B);
7005 if (NestedLoopCount == 0)
7008 assert((CurContext->isDependentContext() || B.builtAll()) &&
7009 "omp for loop exprs were not built");
7011 if (!CurContext->isDependentContext()) {
7012 // Finalize the clauses that need pre-built expressions for CodeGen.
7013 for (auto C : Clauses) {
7014 if (auto LC = dyn_cast<OMPLinearClause>(C))
7015 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
7016 B.NumIterations, *this, CurScope,
7022 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
7023 // The grainsize clause and num_tasks clause are mutually exclusive and may
7024 // not appear on the same taskloop directive.
7025 if (checkGrainsizeNumTasksClauses(*this, Clauses))
7028 getCurFunction()->setHasBranchProtectedScope();
7029 return OMPTaskLoopSimdDirective::Create(Context, StartLoc, EndLoc,
7030 NestedLoopCount, Clauses, AStmt, B);
7033 StmtResult Sema::ActOnOpenMPDistributeDirective(
7034 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7035 SourceLocation EndLoc,
7036 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7040 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
7041 OMPLoopDirective::HelperExprs B;
7042 // In presence of clause 'collapse' with number of loops, it will
7043 // define the nested loops number.
7044 unsigned NestedLoopCount =
7045 CheckOpenMPLoop(OMPD_distribute, getCollapseNumberExpr(Clauses),
7046 nullptr /*ordered not a clause on distribute*/, AStmt,
7047 *this, *DSAStack, VarsWithImplicitDSA, B);
7048 if (NestedLoopCount == 0)
7051 assert((CurContext->isDependentContext() || B.builtAll()) &&
7052 "omp for loop exprs were not built");
7054 getCurFunction()->setHasBranchProtectedScope();
7055 return OMPDistributeDirective::Create(Context, StartLoc, EndLoc,
7056 NestedLoopCount, Clauses, AStmt, B);
7059 StmtResult Sema::ActOnOpenMPDistributeParallelForDirective(
7060 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7061 SourceLocation EndLoc,
7062 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7066 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7067 // 1.2.2 OpenMP Language Terminology
7068 // Structured block - An executable statement with a single entry at the
7069 // top and a single exit at the bottom.
7070 // The point of exit cannot be a branch out of the structured block.
7071 // longjmp() and throw() must not violate the entry/exit criteria.
7072 CS->getCapturedDecl()->setNothrow();
7074 OMPLoopDirective::HelperExprs B;
7075 // In presence of clause 'collapse' with number of loops, it will
7076 // define the nested loops number.
7077 unsigned NestedLoopCount = CheckOpenMPLoop(
7078 OMPD_distribute_parallel_for, getCollapseNumberExpr(Clauses),
7079 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
7080 VarsWithImplicitDSA, B);
7081 if (NestedLoopCount == 0)
7084 assert((CurContext->isDependentContext() || B.builtAll()) &&
7085 "omp for loop exprs were not built");
7087 getCurFunction()->setHasBranchProtectedScope();
7088 return OMPDistributeParallelForDirective::Create(
7089 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
7092 StmtResult Sema::ActOnOpenMPDistributeParallelForSimdDirective(
7093 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7094 SourceLocation EndLoc,
7095 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7099 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7100 // 1.2.2 OpenMP Language Terminology
7101 // Structured block - An executable statement with a single entry at the
7102 // top and a single exit at the bottom.
7103 // The point of exit cannot be a branch out of the structured block.
7104 // longjmp() and throw() must not violate the entry/exit criteria.
7105 CS->getCapturedDecl()->setNothrow();
7107 OMPLoopDirective::HelperExprs B;
7108 // In presence of clause 'collapse' with number of loops, it will
7109 // define the nested loops number.
7110 unsigned NestedLoopCount = CheckOpenMPLoop(
7111 OMPD_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
7112 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
7113 VarsWithImplicitDSA, B);
7114 if (NestedLoopCount == 0)
7117 assert((CurContext->isDependentContext() || B.builtAll()) &&
7118 "omp for loop exprs were not built");
7120 if (checkSimdlenSafelenSpecified(*this, Clauses))
7123 getCurFunction()->setHasBranchProtectedScope();
7124 return OMPDistributeParallelForSimdDirective::Create(
7125 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
7128 StmtResult Sema::ActOnOpenMPDistributeSimdDirective(
7129 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7130 SourceLocation EndLoc,
7131 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7135 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7136 // 1.2.2 OpenMP Language Terminology
7137 // Structured block - An executable statement with a single entry at the
7138 // top and a single exit at the bottom.
7139 // The point of exit cannot be a branch out of the structured block.
7140 // longjmp() and throw() must not violate the entry/exit criteria.
7141 CS->getCapturedDecl()->setNothrow();
7143 OMPLoopDirective::HelperExprs B;
7144 // In presence of clause 'collapse' with number of loops, it will
7145 // define the nested loops number.
7146 unsigned NestedLoopCount =
7147 CheckOpenMPLoop(OMPD_distribute_simd, getCollapseNumberExpr(Clauses),
7148 nullptr /*ordered not a clause on distribute*/, AStmt,
7149 *this, *DSAStack, VarsWithImplicitDSA, B);
7150 if (NestedLoopCount == 0)
7153 assert((CurContext->isDependentContext() || B.builtAll()) &&
7154 "omp for loop exprs were not built");
7156 if (checkSimdlenSafelenSpecified(*this, Clauses))
7159 getCurFunction()->setHasBranchProtectedScope();
7160 return OMPDistributeSimdDirective::Create(Context, StartLoc, EndLoc,
7161 NestedLoopCount, Clauses, AStmt, B);
7164 StmtResult Sema::ActOnOpenMPTargetParallelForSimdDirective(
7165 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7166 SourceLocation EndLoc,
7167 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
7171 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
7172 // 1.2.2 OpenMP Language Terminology
7173 // Structured block - An executable statement with a single entry at the
7174 // top and a single exit at the bottom.
7175 // The point of exit cannot be a branch out of the structured block.
7176 // longjmp() and throw() must not violate the entry/exit criteria.
7177 CS->getCapturedDecl()->setNothrow();
7179 OMPLoopDirective::HelperExprs B;
7180 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
7181 // define the nested loops number.
7182 unsigned NestedLoopCount = CheckOpenMPLoop(
7183 OMPD_target_parallel_for_simd, getCollapseNumberExpr(Clauses),
7184 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
7185 VarsWithImplicitDSA, B);
7186 if (NestedLoopCount == 0)
7189 assert((CurContext->isDependentContext() || B.builtAll()) &&
7190 "omp target parallel for simd loop exprs were not built");
7192 if (!CurContext->isDependentContext()) {
7193 // Finalize the clauses that need pre-built expressions for CodeGen.
7194 for (auto C : Clauses) {
7195 if (auto LC = dyn_cast<OMPLinearClause>(C))
7196 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
7197 B.NumIterations, *this, CurScope,
7202 if (checkSimdlenSafelenSpecified(*this, Clauses))
7205 getCurFunction()->setHasBranchProtectedScope();
7206 return OMPTargetParallelForSimdDirective::Create(
7207 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
7210 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
7211 SourceLocation StartLoc,
7212 SourceLocation LParenLoc,
7213 SourceLocation EndLoc) {
7214 OMPClause *Res = nullptr;
7217 Res = ActOnOpenMPFinalClause(Expr, StartLoc, LParenLoc, EndLoc);
7219 case OMPC_num_threads:
7220 Res = ActOnOpenMPNumThreadsClause(Expr, StartLoc, LParenLoc, EndLoc);
7223 Res = ActOnOpenMPSafelenClause(Expr, StartLoc, LParenLoc, EndLoc);
7226 Res = ActOnOpenMPSimdlenClause(Expr, StartLoc, LParenLoc, EndLoc);
7229 Res = ActOnOpenMPCollapseClause(Expr, StartLoc, LParenLoc, EndLoc);
7232 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Expr);
7235 Res = ActOnOpenMPDeviceClause(Expr, StartLoc, LParenLoc, EndLoc);
7237 case OMPC_num_teams:
7238 Res = ActOnOpenMPNumTeamsClause(Expr, StartLoc, LParenLoc, EndLoc);
7240 case OMPC_thread_limit:
7241 Res = ActOnOpenMPThreadLimitClause(Expr, StartLoc, LParenLoc, EndLoc);
7244 Res = ActOnOpenMPPriorityClause(Expr, StartLoc, LParenLoc, EndLoc);
7246 case OMPC_grainsize:
7247 Res = ActOnOpenMPGrainsizeClause(Expr, StartLoc, LParenLoc, EndLoc);
7249 case OMPC_num_tasks:
7250 Res = ActOnOpenMPNumTasksClause(Expr, StartLoc, LParenLoc, EndLoc);
7253 Res = ActOnOpenMPHintClause(Expr, StartLoc, LParenLoc, EndLoc);
7257 case OMPC_proc_bind:
7260 case OMPC_firstprivate:
7261 case OMPC_lastprivate:
7263 case OMPC_reduction:
7267 case OMPC_copyprivate:
7270 case OMPC_mergeable:
7271 case OMPC_threadprivate:
7283 case OMPC_dist_schedule:
7284 case OMPC_defaultmap:
7289 case OMPC_use_device_ptr:
7290 case OMPC_is_device_ptr:
7291 llvm_unreachable("Clause is not allowed.");
7296 OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
7297 Expr *Condition, SourceLocation StartLoc,
7298 SourceLocation LParenLoc,
7299 SourceLocation NameModifierLoc,
7300 SourceLocation ColonLoc,
7301 SourceLocation EndLoc) {
7302 Expr *ValExpr = Condition;
7303 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
7304 !Condition->isInstantiationDependent() &&
7305 !Condition->containsUnexpandedParameterPack()) {
7306 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
7307 if (Val.isInvalid())
7310 ValExpr = MakeFullExpr(Val.get()).get();
7313 return new (Context) OMPIfClause(NameModifier, ValExpr, StartLoc, LParenLoc,
7314 NameModifierLoc, ColonLoc, EndLoc);
7317 OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition,
7318 SourceLocation StartLoc,
7319 SourceLocation LParenLoc,
7320 SourceLocation EndLoc) {
7321 Expr *ValExpr = Condition;
7322 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
7323 !Condition->isInstantiationDependent() &&
7324 !Condition->containsUnexpandedParameterPack()) {
7325 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
7326 if (Val.isInvalid())
7329 ValExpr = MakeFullExpr(Val.get()).get();
7332 return new (Context) OMPFinalClause(ValExpr, StartLoc, LParenLoc, EndLoc);
7334 ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc,
7339 class IntConvertDiagnoser : public ICEConvertDiagnoser {
7341 IntConvertDiagnoser()
7342 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false, false, true) {}
7343 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
7344 QualType T) override {
7345 return S.Diag(Loc, diag::err_omp_not_integral) << T;
7347 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
7348 QualType T) override {
7349 return S.Diag(Loc, diag::err_omp_incomplete_type) << T;
7351 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
7353 QualType ConvTy) override {
7354 return S.Diag(Loc, diag::err_omp_explicit_conversion) << T << ConvTy;
7356 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
7357 QualType ConvTy) override {
7358 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
7359 << ConvTy->isEnumeralType() << ConvTy;
7361 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
7362 QualType T) override {
7363 return S.Diag(Loc, diag::err_omp_ambiguous_conversion) << T;
7365 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
7366 QualType ConvTy) override {
7367 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
7368 << ConvTy->isEnumeralType() << ConvTy;
7370 SemaDiagnosticBuilder diagnoseConversion(Sema &, SourceLocation, QualType,
7371 QualType) override {
7372 llvm_unreachable("conversion functions are permitted");
7375 return PerformContextualImplicitConversion(Loc, Op, ConvertDiagnoser);
7378 static bool IsNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef,
7379 OpenMPClauseKind CKind,
7380 bool StrictlyPositive) {
7381 if (!ValExpr->isTypeDependent() && !ValExpr->isValueDependent() &&
7382 !ValExpr->isInstantiationDependent()) {
7383 SourceLocation Loc = ValExpr->getExprLoc();
7385 SemaRef.PerformOpenMPImplicitIntegerConversion(Loc, ValExpr);
7386 if (Value.isInvalid())
7389 ValExpr = Value.get();
7390 // The expression must evaluate to a non-negative integer value.
7391 llvm::APSInt Result;
7392 if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) &&
7393 Result.isSigned() &&
7394 !((!StrictlyPositive && Result.isNonNegative()) ||
7395 (StrictlyPositive && Result.isStrictlyPositive()))) {
7396 SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
7397 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
7398 << ValExpr->getSourceRange();
7405 OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads,
7406 SourceLocation StartLoc,
7407 SourceLocation LParenLoc,
7408 SourceLocation EndLoc) {
7409 Expr *ValExpr = NumThreads;
7411 // OpenMP [2.5, Restrictions]
7412 // The num_threads expression must evaluate to a positive integer value.
7413 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_threads,
7414 /*StrictlyPositive=*/true))
7417 return new (Context)
7418 OMPNumThreadsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
7421 ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
7422 OpenMPClauseKind CKind,
7423 bool StrictlyPositive) {
7426 if (E->isValueDependent() || E->isTypeDependent() ||
7427 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
7429 llvm::APSInt Result;
7430 ExprResult ICE = VerifyIntegerConstantExpression(E, &Result);
7431 if (ICE.isInvalid())
7433 if ((StrictlyPositive && !Result.isStrictlyPositive()) ||
7434 (!StrictlyPositive && !Result.isNonNegative())) {
7435 Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
7436 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
7437 << E->getSourceRange();
7440 if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
7441 Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
7442 << E->getSourceRange();
7445 if (CKind == OMPC_collapse && DSAStack->getAssociatedLoops() == 1)
7446 DSAStack->setAssociatedLoops(Result.getExtValue());
7447 else if (CKind == OMPC_ordered)
7448 DSAStack->setAssociatedLoops(Result.getExtValue());
7452 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
7453 SourceLocation LParenLoc,
7454 SourceLocation EndLoc) {
7455 // OpenMP [2.8.1, simd construct, Description]
7456 // The parameter of the safelen clause must be a constant
7457 // positive integer expression.
7458 ExprResult Safelen = VerifyPositiveIntegerConstantInClause(Len, OMPC_safelen);
7459 if (Safelen.isInvalid())
7461 return new (Context)
7462 OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc);
7465 OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
7466 SourceLocation LParenLoc,
7467 SourceLocation EndLoc) {
7468 // OpenMP [2.8.1, simd construct, Description]
7469 // The parameter of the simdlen clause must be a constant
7470 // positive integer expression.
7471 ExprResult Simdlen = VerifyPositiveIntegerConstantInClause(Len, OMPC_simdlen);
7472 if (Simdlen.isInvalid())
7474 return new (Context)
7475 OMPSimdlenClause(Simdlen.get(), StartLoc, LParenLoc, EndLoc);
7478 OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops,
7479 SourceLocation StartLoc,
7480 SourceLocation LParenLoc,
7481 SourceLocation EndLoc) {
7482 // OpenMP [2.7.1, loop construct, Description]
7483 // OpenMP [2.8.1, simd construct, Description]
7484 // OpenMP [2.9.6, distribute construct, Description]
7485 // The parameter of the collapse clause must be a constant
7486 // positive integer expression.
7487 ExprResult NumForLoopsResult =
7488 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_collapse);
7489 if (NumForLoopsResult.isInvalid())
7491 return new (Context)
7492 OMPCollapseClause(NumForLoopsResult.get(), StartLoc, LParenLoc, EndLoc);
7495 OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc,
7496 SourceLocation EndLoc,
7497 SourceLocation LParenLoc,
7498 Expr *NumForLoops) {
7499 // OpenMP [2.7.1, loop construct, Description]
7500 // OpenMP [2.8.1, simd construct, Description]
7501 // OpenMP [2.9.6, distribute construct, Description]
7502 // The parameter of the ordered clause must be a constant
7503 // positive integer expression if any.
7504 if (NumForLoops && LParenLoc.isValid()) {
7505 ExprResult NumForLoopsResult =
7506 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered);
7507 if (NumForLoopsResult.isInvalid())
7509 NumForLoops = NumForLoopsResult.get();
7511 NumForLoops = nullptr;
7512 DSAStack->setOrderedRegion(/*IsOrdered=*/true, NumForLoops);
7513 return new (Context)
7514 OMPOrderedClause(NumForLoops, StartLoc, LParenLoc, EndLoc);
7517 OMPClause *Sema::ActOnOpenMPSimpleClause(
7518 OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc,
7519 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {
7520 OMPClause *Res = nullptr;
7524 ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument),
7525 ArgumentLoc, StartLoc, LParenLoc, EndLoc);
7527 case OMPC_proc_bind:
7528 Res = ActOnOpenMPProcBindClause(
7529 static_cast<OpenMPProcBindClauseKind>(Argument), ArgumentLoc, StartLoc,
7534 case OMPC_num_threads:
7540 case OMPC_firstprivate:
7541 case OMPC_lastprivate:
7543 case OMPC_reduction:
7547 case OMPC_copyprivate:
7551 case OMPC_mergeable:
7552 case OMPC_threadprivate:
7564 case OMPC_num_teams:
7565 case OMPC_thread_limit:
7567 case OMPC_grainsize:
7569 case OMPC_num_tasks:
7571 case OMPC_dist_schedule:
7572 case OMPC_defaultmap:
7577 case OMPC_use_device_ptr:
7578 case OMPC_is_device_ptr:
7579 llvm_unreachable("Clause is not allowed.");
7585 getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last,
7586 ArrayRef<unsigned> Exclude = llvm::None) {
7588 unsigned Bound = Last >= 2 ? Last - 2 : 0;
7589 unsigned Skipped = Exclude.size();
7590 auto S = Exclude.begin(), E = Exclude.end();
7591 for (unsigned i = First; i < Last; ++i) {
7592 if (std::find(S, E, i) != E) {
7597 Values += getOpenMPSimpleClauseTypeName(K, i);
7599 if (i == Bound - Skipped)
7601 else if (i != Bound + 1 - Skipped)
7607 OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
7608 SourceLocation KindKwLoc,
7609 SourceLocation StartLoc,
7610 SourceLocation LParenLoc,
7611 SourceLocation EndLoc) {
7612 if (Kind == OMPC_DEFAULT_unknown) {
7613 static_assert(OMPC_DEFAULT_unknown > 0,
7614 "OMPC_DEFAULT_unknown not greater than 0");
7615 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
7616 << getListOfPossibleValues(OMPC_default, /*First=*/0,
7617 /*Last=*/OMPC_DEFAULT_unknown)
7618 << getOpenMPClauseName(OMPC_default);
7622 case OMPC_DEFAULT_none:
7623 DSAStack->setDefaultDSANone(KindKwLoc);
7625 case OMPC_DEFAULT_shared:
7626 DSAStack->setDefaultDSAShared(KindKwLoc);
7628 case OMPC_DEFAULT_unknown:
7629 llvm_unreachable("Clause kind is not allowed.");
7632 return new (Context)
7633 OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
7636 OMPClause *Sema::ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
7637 SourceLocation KindKwLoc,
7638 SourceLocation StartLoc,
7639 SourceLocation LParenLoc,
7640 SourceLocation EndLoc) {
7641 if (Kind == OMPC_PROC_BIND_unknown) {
7642 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
7643 << getListOfPossibleValues(OMPC_proc_bind, /*First=*/0,
7644 /*Last=*/OMPC_PROC_BIND_unknown)
7645 << getOpenMPClauseName(OMPC_proc_bind);
7648 return new (Context)
7649 OMPProcBindClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
7652 OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
7653 OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
7654 SourceLocation StartLoc, SourceLocation LParenLoc,
7655 ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc,
7656 SourceLocation EndLoc) {
7657 OMPClause *Res = nullptr;
7660 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
7661 assert(Argument.size() == NumberOfElements &&
7662 ArgumentLoc.size() == NumberOfElements);
7663 Res = ActOnOpenMPScheduleClause(
7664 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier1]),
7665 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier2]),
7666 static_cast<OpenMPScheduleClauseKind>(Argument[ScheduleKind]), Expr,
7667 StartLoc, LParenLoc, ArgumentLoc[Modifier1], ArgumentLoc[Modifier2],
7668 ArgumentLoc[ScheduleKind], DelimLoc, EndLoc);
7671 assert(Argument.size() == 1 && ArgumentLoc.size() == 1);
7672 Res = ActOnOpenMPIfClause(static_cast<OpenMPDirectiveKind>(Argument.back()),
7673 Expr, StartLoc, LParenLoc, ArgumentLoc.back(),
7676 case OMPC_dist_schedule:
7677 Res = ActOnOpenMPDistScheduleClause(
7678 static_cast<OpenMPDistScheduleClauseKind>(Argument.back()), Expr,
7679 StartLoc, LParenLoc, ArgumentLoc.back(), DelimLoc, EndLoc);
7681 case OMPC_defaultmap:
7682 enum { Modifier, DefaultmapKind };
7683 Res = ActOnOpenMPDefaultmapClause(
7684 static_cast<OpenMPDefaultmapClauseModifier>(Argument[Modifier]),
7685 static_cast<OpenMPDefaultmapClauseKind>(Argument[DefaultmapKind]),
7686 StartLoc, LParenLoc, ArgumentLoc[Modifier],
7687 ArgumentLoc[DefaultmapKind], EndLoc);
7690 case OMPC_num_threads:
7695 case OMPC_proc_bind:
7697 case OMPC_firstprivate:
7698 case OMPC_lastprivate:
7700 case OMPC_reduction:
7704 case OMPC_copyprivate:
7708 case OMPC_mergeable:
7709 case OMPC_threadprivate:
7721 case OMPC_num_teams:
7722 case OMPC_thread_limit:
7724 case OMPC_grainsize:
7726 case OMPC_num_tasks:
7732 case OMPC_use_device_ptr:
7733 case OMPC_is_device_ptr:
7734 llvm_unreachable("Clause is not allowed.");
7739 static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1,
7740 OpenMPScheduleClauseModifier M2,
7741 SourceLocation M1Loc, SourceLocation M2Loc) {
7742 if (M1 == OMPC_SCHEDULE_MODIFIER_unknown && M1Loc.isValid()) {
7743 SmallVector<unsigned, 2> Excluded;
7744 if (M2 != OMPC_SCHEDULE_MODIFIER_unknown)
7745 Excluded.push_back(M2);
7746 if (M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic)
7747 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_monotonic);
7748 if (M2 == OMPC_SCHEDULE_MODIFIER_monotonic)
7749 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_nonmonotonic);
7750 S.Diag(M1Loc, diag::err_omp_unexpected_clause_value)
7751 << getListOfPossibleValues(OMPC_schedule,
7752 /*First=*/OMPC_SCHEDULE_MODIFIER_unknown + 1,
7753 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7755 << getOpenMPClauseName(OMPC_schedule);
7761 OMPClause *Sema::ActOnOpenMPScheduleClause(
7762 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
7763 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
7764 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
7765 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
7766 if (checkScheduleModifiers(*this, M1, M2, M1Loc, M2Loc) ||
7767 checkScheduleModifiers(*this, M2, M1, M2Loc, M1Loc))
7769 // OpenMP, 2.7.1, Loop Construct, Restrictions
7770 // Either the monotonic modifier or the nonmonotonic modifier can be specified
7772 if ((M1 == M2 && M1 != OMPC_SCHEDULE_MODIFIER_unknown) ||
7773 (M1 == OMPC_SCHEDULE_MODIFIER_monotonic &&
7774 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) ||
7775 (M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic &&
7776 M2 == OMPC_SCHEDULE_MODIFIER_monotonic)) {
7777 Diag(M2Loc, diag::err_omp_unexpected_schedule_modifier)
7778 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M2)
7779 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M1);
7782 if (Kind == OMPC_SCHEDULE_unknown) {
7784 if (M1Loc.isInvalid() && M2Loc.isInvalid()) {
7785 unsigned Exclude[] = {OMPC_SCHEDULE_unknown};
7786 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7787 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7790 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7791 /*Last=*/OMPC_SCHEDULE_unknown);
7793 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
7794 << Values << getOpenMPClauseName(OMPC_schedule);
7797 // OpenMP, 2.7.1, Loop Construct, Restrictions
7798 // The nonmonotonic modifier can only be specified with schedule(dynamic) or
7799 // schedule(guided).
7800 if ((M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
7801 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
7802 Kind != OMPC_SCHEDULE_dynamic && Kind != OMPC_SCHEDULE_guided) {
7803 Diag(M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ? M1Loc : M2Loc,
7804 diag::err_omp_schedule_nonmonotonic_static);
7807 Expr *ValExpr = ChunkSize;
7808 Stmt *HelperValStmt = nullptr;
7810 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
7811 !ChunkSize->isInstantiationDependent() &&
7812 !ChunkSize->containsUnexpandedParameterPack()) {
7813 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
7815 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
7816 if (Val.isInvalid())
7819 ValExpr = Val.get();
7821 // OpenMP [2.7.1, Restrictions]
7822 // chunk_size must be a loop invariant integer expression with a positive
7824 llvm::APSInt Result;
7825 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
7826 if (Result.isSigned() && !Result.isStrictlyPositive()) {
7827 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
7828 << "schedule" << 1 << ChunkSize->getSourceRange();
7831 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
7832 !CurContext->isDependentContext()) {
7833 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7834 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7835 HelperValStmt = buildPreInits(Context, Captures);
7840 return new (Context)
7841 OMPScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, Kind,
7842 ValExpr, HelperValStmt, M1, M1Loc, M2, M2Loc);
7845 OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
7846 SourceLocation StartLoc,
7847 SourceLocation EndLoc) {
7848 OMPClause *Res = nullptr;
7851 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc);
7854 Res = ActOnOpenMPNowaitClause(StartLoc, EndLoc);
7857 Res = ActOnOpenMPUntiedClause(StartLoc, EndLoc);
7859 case OMPC_mergeable:
7860 Res = ActOnOpenMPMergeableClause(StartLoc, EndLoc);
7863 Res = ActOnOpenMPReadClause(StartLoc, EndLoc);
7866 Res = ActOnOpenMPWriteClause(StartLoc, EndLoc);
7869 Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc);
7872 Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc);
7875 Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
7878 Res = ActOnOpenMPThreadsClause(StartLoc, EndLoc);
7881 Res = ActOnOpenMPSIMDClause(StartLoc, EndLoc);
7884 Res = ActOnOpenMPNogroupClause(StartLoc, EndLoc);
7888 case OMPC_num_threads:
7894 case OMPC_firstprivate:
7895 case OMPC_lastprivate:
7897 case OMPC_reduction:
7901 case OMPC_copyprivate:
7903 case OMPC_proc_bind:
7904 case OMPC_threadprivate:
7909 case OMPC_num_teams:
7910 case OMPC_thread_limit:
7912 case OMPC_grainsize:
7913 case OMPC_num_tasks:
7915 case OMPC_dist_schedule:
7916 case OMPC_defaultmap:
7921 case OMPC_use_device_ptr:
7922 case OMPC_is_device_ptr:
7923 llvm_unreachable("Clause is not allowed.");
7928 OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc,
7929 SourceLocation EndLoc) {
7930 DSAStack->setNowaitRegion();
7931 return new (Context) OMPNowaitClause(StartLoc, EndLoc);
7934 OMPClause *Sema::ActOnOpenMPUntiedClause(SourceLocation StartLoc,
7935 SourceLocation EndLoc) {
7936 return new (Context) OMPUntiedClause(StartLoc, EndLoc);
7939 OMPClause *Sema::ActOnOpenMPMergeableClause(SourceLocation StartLoc,
7940 SourceLocation EndLoc) {
7941 return new (Context) OMPMergeableClause(StartLoc, EndLoc);
7944 OMPClause *Sema::ActOnOpenMPReadClause(SourceLocation StartLoc,
7945 SourceLocation EndLoc) {
7946 return new (Context) OMPReadClause(StartLoc, EndLoc);
7949 OMPClause *Sema::ActOnOpenMPWriteClause(SourceLocation StartLoc,
7950 SourceLocation EndLoc) {
7951 return new (Context) OMPWriteClause(StartLoc, EndLoc);
7954 OMPClause *Sema::ActOnOpenMPUpdateClause(SourceLocation StartLoc,
7955 SourceLocation EndLoc) {
7956 return new (Context) OMPUpdateClause(StartLoc, EndLoc);
7959 OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc,
7960 SourceLocation EndLoc) {
7961 return new (Context) OMPCaptureClause(StartLoc, EndLoc);
7964 OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
7965 SourceLocation EndLoc) {
7966 return new (Context) OMPSeqCstClause(StartLoc, EndLoc);
7969 OMPClause *Sema::ActOnOpenMPThreadsClause(SourceLocation StartLoc,
7970 SourceLocation EndLoc) {
7971 return new (Context) OMPThreadsClause(StartLoc, EndLoc);
7974 OMPClause *Sema::ActOnOpenMPSIMDClause(SourceLocation StartLoc,
7975 SourceLocation EndLoc) {
7976 return new (Context) OMPSIMDClause(StartLoc, EndLoc);
7979 OMPClause *Sema::ActOnOpenMPNogroupClause(SourceLocation StartLoc,
7980 SourceLocation EndLoc) {
7981 return new (Context) OMPNogroupClause(StartLoc, EndLoc);
7984 OMPClause *Sema::ActOnOpenMPVarListClause(
7985 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
7986 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc,
7987 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
7988 const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
7989 OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
7990 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
7991 SourceLocation DepLinMapLoc) {
7992 OMPClause *Res = nullptr;
7995 Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7997 case OMPC_firstprivate:
7998 Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8000 case OMPC_lastprivate:
8001 Res = ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8004 Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc);
8006 case OMPC_reduction:
8007 Res = ActOnOpenMPReductionClause(VarList, StartLoc, LParenLoc, ColonLoc,
8008 EndLoc, ReductionIdScopeSpec, ReductionId);
8011 Res = ActOnOpenMPLinearClause(VarList, TailExpr, StartLoc, LParenLoc,
8012 LinKind, DepLinMapLoc, ColonLoc, EndLoc);
8015 Res = ActOnOpenMPAlignedClause(VarList, TailExpr, StartLoc, LParenLoc,
8019 Res = ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, EndLoc);
8021 case OMPC_copyprivate:
8022 Res = ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
8025 Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc);
8028 Res = ActOnOpenMPDependClause(DepKind, DepLinMapLoc, ColonLoc, VarList,
8029 StartLoc, LParenLoc, EndLoc);
8032 Res = ActOnOpenMPMapClause(MapTypeModifier, MapType, IsMapTypeImplicit,
8033 DepLinMapLoc, ColonLoc, VarList, StartLoc,
8037 Res = ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
8040 Res = ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc, EndLoc);
8042 case OMPC_use_device_ptr:
8043 Res = ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
8045 case OMPC_is_device_ptr:
8046 Res = ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
8050 case OMPC_num_threads:
8055 case OMPC_proc_bind:
8060 case OMPC_mergeable:
8061 case OMPC_threadprivate:
8070 case OMPC_num_teams:
8071 case OMPC_thread_limit:
8073 case OMPC_grainsize:
8075 case OMPC_num_tasks:
8077 case OMPC_dist_schedule:
8078 case OMPC_defaultmap:
8081 llvm_unreachable("Clause is not allowed.");
8086 ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
8087 ExprObjectKind OK, SourceLocation Loc) {
8088 ExprResult Res = BuildDeclRefExpr(
8089 Capture, Capture->getType().getNonReferenceType(), VK_LValue, Loc);
8090 if (!Res.isUsable())
8092 if (OK == OK_Ordinary && !getLangOpts().CPlusPlus) {
8093 Res = CreateBuiltinUnaryOp(Loc, UO_Deref, Res.get());
8094 if (!Res.isUsable())
8097 if (VK != VK_LValue && Res.get()->isGLValue()) {
8098 Res = DefaultLvalueConversion(Res.get());
8099 if (!Res.isUsable())
8105 static std::pair<ValueDecl *, bool>
8106 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
8107 SourceRange &ERange, bool AllowArraySection = false) {
8108 if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() ||
8109 RefExpr->containsUnexpandedParameterPack())
8110 return std::make_pair(nullptr, true);
8112 // OpenMP [3.1, C/C++]
8113 // A list item is a variable name.
8114 // OpenMP [2.9.3.3, Restrictions, p.1]
8115 // A variable that is part of another variable (as an array or
8116 // structure element) cannot appear in a private clause.
8117 RefExpr = RefExpr->IgnoreParens();
8122 } IsArrayExpr = NoArrayExpr;
8123 if (AllowArraySection) {
8124 if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) {
8125 auto *Base = ASE->getBase()->IgnoreParenImpCasts();
8126 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
8127 Base = TempASE->getBase()->IgnoreParenImpCasts();
8129 IsArrayExpr = ArraySubscript;
8130 } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) {
8131 auto *Base = OASE->getBase()->IgnoreParenImpCasts();
8132 while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base))
8133 Base = TempOASE->getBase()->IgnoreParenImpCasts();
8134 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
8135 Base = TempASE->getBase()->IgnoreParenImpCasts();
8137 IsArrayExpr = OMPArraySection;
8140 ELoc = RefExpr->getExprLoc();
8141 ERange = RefExpr->getSourceRange();
8142 RefExpr = RefExpr->IgnoreParenImpCasts();
8143 auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
8144 auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr);
8145 if ((!DE || !isa<VarDecl>(DE->getDecl())) &&
8146 (S.getCurrentThisType().isNull() || !ME ||
8147 !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) ||
8148 !isa<FieldDecl>(ME->getMemberDecl()))) {
8149 if (IsArrayExpr != NoArrayExpr)
8150 S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr
8155 ? diag::err_omp_expected_var_name_member_expr_or_array_item
8156 : diag::err_omp_expected_var_name_member_expr)
8157 << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange;
8159 return std::make_pair(nullptr, false);
8161 return std::make_pair(DE ? DE->getDecl() : ME->getMemberDecl(), false);
8164 OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
8165 SourceLocation StartLoc,
8166 SourceLocation LParenLoc,
8167 SourceLocation EndLoc) {
8168 SmallVector<Expr *, 8> Vars;
8169 SmallVector<Expr *, 8> PrivateCopies;
8170 for (auto &RefExpr : VarList) {
8171 assert(RefExpr && "NULL expr in OpenMP private clause.");
8172 SourceLocation ELoc;
8174 Expr *SimpleRefExpr = RefExpr;
8175 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8177 // It will be analyzed later.
8178 Vars.push_back(RefExpr);
8179 PrivateCopies.push_back(nullptr);
8181 ValueDecl *D = Res.first;
8185 QualType Type = D->getType();
8186 auto *VD = dyn_cast<VarDecl>(D);
8188 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8189 // A variable that appears in a private clause must not have an incomplete
8190 // type or a reference type.
8191 if (RequireCompleteType(ELoc, Type, diag::err_omp_private_incomplete_type))
8193 Type = Type.getNonReferenceType();
8195 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8197 // Variables with the predetermined data-sharing attributes may not be
8198 // listed in data-sharing attributes clauses, except for the cases
8199 // listed below. For these exceptions only, listing a predetermined
8200 // variable in a data-sharing attribute clause is allowed and overrides
8201 // the variable's predetermined data-sharing attributes.
8202 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8203 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) {
8204 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8205 << getOpenMPClauseName(OMPC_private);
8206 ReportOriginalDSA(*this, DSAStack, D, DVar);
8210 // Variably modified types are not supported for tasks.
8211 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
8212 isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) {
8213 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
8214 << getOpenMPClauseName(OMPC_private) << Type
8215 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8218 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8219 Diag(D->getLocation(),
8220 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8225 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
8226 // A list item cannot appear in both a map clause and a data-sharing
8227 // attribute clause on the same construct
8228 if (DSAStack->getCurrentDirective() == OMPD_target) {
8229 if (DSAStack->checkMappableExprComponentListsForDecl(
8230 VD, /* CurrentRegionOnly = */ true,
8231 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef)
8232 -> bool { return true; })) {
8233 Diag(ELoc, diag::err_omp_variable_in_map_and_dsa)
8234 << getOpenMPClauseName(OMPC_private)
8235 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8236 ReportOriginalDSA(*this, DSAStack, D, DVar);
8241 // OpenMP [2.9.3.3, Restrictions, C/C++, p.1]
8242 // A variable of class type (or array thereof) that appears in a private
8243 // clause requires an accessible, unambiguous default constructor for the
8245 // Generate helper private variable and initialize it with the default
8246 // value. The address of the original variable is replaced by the address of
8247 // the new private variable in CodeGen. This new variable is not added to
8248 // IdResolver, so the code in the OpenMP region uses original variable for
8249 // proper diagnostics.
8250 Type = Type.getUnqualifiedType();
8251 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
8252 D->hasAttrs() ? &D->getAttrs() : nullptr);
8253 ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false);
8254 if (VDPrivate->isInvalidDecl())
8256 auto VDPrivateRefExpr = buildDeclRefExpr(
8257 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
8259 DeclRefExpr *Ref = nullptr;
8260 if (!VD && !CurContext->isDependentContext())
8261 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8262 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_private, Ref);
8263 Vars.push_back((VD || CurContext->isDependentContext())
8264 ? RefExpr->IgnoreParens()
8266 PrivateCopies.push_back(VDPrivateRefExpr);
8272 return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
8277 class DiagsUninitializedSeveretyRAII {
8279 DiagnosticsEngine &Diags;
8280 SourceLocation SavedLoc;
8284 DiagsUninitializedSeveretyRAII(DiagnosticsEngine &Diags, SourceLocation Loc,
8286 : Diags(Diags), SavedLoc(Loc), IsIgnored(IsIgnored) {
8288 Diags.setSeverity(/*Diag*/ diag::warn_uninit_self_reference_in_init,
8289 /*Map*/ diag::Severity::Ignored, Loc);
8292 ~DiagsUninitializedSeveretyRAII() {
8294 Diags.popMappings(SavedLoc);
8299 OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
8300 SourceLocation StartLoc,
8301 SourceLocation LParenLoc,
8302 SourceLocation EndLoc) {
8303 SmallVector<Expr *, 8> Vars;
8304 SmallVector<Expr *, 8> PrivateCopies;
8305 SmallVector<Expr *, 8> Inits;
8306 SmallVector<Decl *, 4> ExprCaptures;
8307 bool IsImplicitClause =
8308 StartLoc.isInvalid() && LParenLoc.isInvalid() && EndLoc.isInvalid();
8309 auto ImplicitClauseLoc = DSAStack->getConstructLoc();
8311 for (auto &RefExpr : VarList) {
8312 assert(RefExpr && "NULL expr in OpenMP firstprivate clause.");
8313 SourceLocation ELoc;
8315 Expr *SimpleRefExpr = RefExpr;
8316 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8318 // It will be analyzed later.
8319 Vars.push_back(RefExpr);
8320 PrivateCopies.push_back(nullptr);
8321 Inits.push_back(nullptr);
8323 ValueDecl *D = Res.first;
8327 ELoc = IsImplicitClause ? ImplicitClauseLoc : ELoc;
8328 QualType Type = D->getType();
8329 auto *VD = dyn_cast<VarDecl>(D);
8331 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8332 // A variable that appears in a private clause must not have an incomplete
8333 // type or a reference type.
8334 if (RequireCompleteType(ELoc, Type,
8335 diag::err_omp_firstprivate_incomplete_type))
8337 Type = Type.getNonReferenceType();
8339 // OpenMP [2.9.3.4, Restrictions, C/C++, p.1]
8340 // A variable of class type (or array thereof) that appears in a private
8341 // clause requires an accessible, unambiguous copy constructor for the
8343 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
8345 // If an implicit firstprivate variable found it was checked already.
8346 DSAStackTy::DSAVarData TopDVar;
8347 if (!IsImplicitClause) {
8348 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8350 bool IsConstant = ElemType.isConstant(Context);
8351 // OpenMP [2.4.13, Data-sharing Attribute Clauses]
8352 // A list item that specifies a given variable may not appear in more
8353 // than one clause on the same directive, except that a variable may be
8354 // specified in both firstprivate and lastprivate clauses.
8355 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_firstprivate &&
8356 DVar.CKind != OMPC_lastprivate && DVar.RefExpr) {
8357 Diag(ELoc, diag::err_omp_wrong_dsa)
8358 << getOpenMPClauseName(DVar.CKind)
8359 << getOpenMPClauseName(OMPC_firstprivate);
8360 ReportOriginalDSA(*this, DSAStack, D, DVar);
8364 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8366 // Variables with the predetermined data-sharing attributes may not be
8367 // listed in data-sharing attributes clauses, except for the cases
8368 // listed below. For these exceptions only, listing a predetermined
8369 // variable in a data-sharing attribute clause is allowed and overrides
8370 // the variable's predetermined data-sharing attributes.
8371 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8372 // in a Construct, C/C++, p.2]
8373 // Variables with const-qualified type having no mutable member may be
8374 // listed in a firstprivate clause, even if they are static data members.
8375 if (!(IsConstant || (VD && VD->isStaticDataMember())) && !DVar.RefExpr &&
8376 DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared) {
8377 Diag(ELoc, diag::err_omp_wrong_dsa)
8378 << getOpenMPClauseName(DVar.CKind)
8379 << getOpenMPClauseName(OMPC_firstprivate);
8380 ReportOriginalDSA(*this, DSAStack, D, DVar);
8384 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8385 // OpenMP [2.9.3.4, Restrictions, p.2]
8386 // A list item that is private within a parallel region must not appear
8387 // in a firstprivate clause on a worksharing construct if any of the
8388 // worksharing regions arising from the worksharing construct ever bind
8389 // to any of the parallel regions arising from the parallel construct.
8390 if (isOpenMPWorksharingDirective(CurrDir) &&
8391 !isOpenMPParallelDirective(CurrDir)) {
8392 DVar = DSAStack->getImplicitDSA(D, true);
8393 if (DVar.CKind != OMPC_shared &&
8394 (isOpenMPParallelDirective(DVar.DKind) ||
8395 DVar.DKind == OMPD_unknown)) {
8396 Diag(ELoc, diag::err_omp_required_access)
8397 << getOpenMPClauseName(OMPC_firstprivate)
8398 << getOpenMPClauseName(OMPC_shared);
8399 ReportOriginalDSA(*this, DSAStack, D, DVar);
8403 // OpenMP [2.9.3.4, Restrictions, p.3]
8404 // A list item that appears in a reduction clause of a parallel construct
8405 // must not appear in a firstprivate clause on a worksharing or task
8406 // construct if any of the worksharing or task regions arising from the
8407 // worksharing or task construct ever bind to any of the parallel regions
8408 // arising from the parallel construct.
8409 // OpenMP [2.9.3.4, Restrictions, p.4]
8410 // A list item that appears in a reduction clause in worksharing
8411 // construct must not appear in a firstprivate clause in a task construct
8412 // encountered during execution of any of the worksharing regions arising
8413 // from the worksharing construct.
8414 if (isOpenMPTaskingDirective(CurrDir)) {
8415 DVar = DSAStack->hasInnermostDSA(
8416 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
8417 [](OpenMPDirectiveKind K) -> bool {
8418 return isOpenMPParallelDirective(K) ||
8419 isOpenMPWorksharingDirective(K);
8422 if (DVar.CKind == OMPC_reduction &&
8423 (isOpenMPParallelDirective(DVar.DKind) ||
8424 isOpenMPWorksharingDirective(DVar.DKind))) {
8425 Diag(ELoc, diag::err_omp_parallel_reduction_in_task_firstprivate)
8426 << getOpenMPDirectiveName(DVar.DKind);
8427 ReportOriginalDSA(*this, DSAStack, D, DVar);
8432 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
8433 // A list item that is private within a teams region must not appear in a
8434 // firstprivate clause on a distribute construct if any of the distribute
8435 // regions arising from the distribute construct ever bind to any of the
8436 // teams regions arising from the teams construct.
8437 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
8438 // A list item that appears in a reduction clause of a teams construct
8439 // must not appear in a firstprivate clause on a distribute construct if
8440 // any of the distribute regions arising from the distribute construct
8441 // ever bind to any of the teams regions arising from the teams construct.
8442 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
8443 // A list item may appear in a firstprivate or lastprivate clause but not
8445 if (CurrDir == OMPD_distribute) {
8446 DVar = DSAStack->hasInnermostDSA(
8447 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_private; },
8448 [](OpenMPDirectiveKind K) -> bool {
8449 return isOpenMPTeamsDirective(K);
8452 if (DVar.CKind == OMPC_private && isOpenMPTeamsDirective(DVar.DKind)) {
8453 Diag(ELoc, diag::err_omp_firstprivate_distribute_private_teams);
8454 ReportOriginalDSA(*this, DSAStack, D, DVar);
8457 DVar = DSAStack->hasInnermostDSA(
8458 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
8459 [](OpenMPDirectiveKind K) -> bool {
8460 return isOpenMPTeamsDirective(K);
8463 if (DVar.CKind == OMPC_reduction &&
8464 isOpenMPTeamsDirective(DVar.DKind)) {
8465 Diag(ELoc, diag::err_omp_firstprivate_distribute_in_teams_reduction);
8466 ReportOriginalDSA(*this, DSAStack, D, DVar);
8469 DVar = DSAStack->getTopDSA(D, false);
8470 if (DVar.CKind == OMPC_lastprivate) {
8471 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
8472 ReportOriginalDSA(*this, DSAStack, D, DVar);
8476 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
8477 // A list item cannot appear in both a map clause and a data-sharing
8478 // attribute clause on the same construct
8479 if (CurrDir == OMPD_target) {
8480 if (DSAStack->checkMappableExprComponentListsForDecl(
8481 VD, /* CurrentRegionOnly = */ true,
8482 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef)
8483 -> bool { return true; })) {
8484 Diag(ELoc, diag::err_omp_variable_in_map_and_dsa)
8485 << getOpenMPClauseName(OMPC_firstprivate)
8486 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8487 ReportOriginalDSA(*this, DSAStack, D, DVar);
8493 // Variably modified types are not supported for tasks.
8494 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
8495 isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) {
8496 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
8497 << getOpenMPClauseName(OMPC_firstprivate) << Type
8498 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8501 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8502 Diag(D->getLocation(),
8503 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8508 Type = Type.getUnqualifiedType();
8509 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
8510 D->hasAttrs() ? &D->getAttrs() : nullptr);
8511 // Generate helper private variable and initialize it with the value of the
8512 // original variable. The address of the original variable is replaced by
8513 // the address of the new private variable in the CodeGen. This new variable
8514 // is not added to IdResolver, so the code in the OpenMP region uses
8515 // original variable for proper diagnostics and variable capturing.
8516 Expr *VDInitRefExpr = nullptr;
8517 // For arrays generate initializer for single element and replace it by the
8518 // original array element in CodeGen.
8519 if (Type->isArrayType()) {
8521 buildVarDecl(*this, RefExpr->getExprLoc(), ElemType, D->getName());
8522 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, ElemType, ELoc);
8523 auto Init = DefaultLvalueConversion(VDInitRefExpr).get();
8524 ElemType = ElemType.getUnqualifiedType();
8525 auto *VDInitTemp = buildVarDecl(*this, RefExpr->getExprLoc(), ElemType,
8526 ".firstprivate.temp");
8527 InitializedEntity Entity =
8528 InitializedEntity::InitializeVariable(VDInitTemp);
8529 InitializationKind Kind = InitializationKind::CreateCopy(ELoc, ELoc);
8531 InitializationSequence InitSeq(*this, Entity, Kind, Init);
8532 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Init);
8533 if (Result.isInvalid())
8534 VDPrivate->setInvalidDecl();
8536 VDPrivate->setInit(Result.getAs<Expr>());
8537 // Remove temp variable declaration.
8538 Context.Deallocate(VDInitTemp);
8540 auto *VDInit = buildVarDecl(*this, RefExpr->getExprLoc(), Type,
8541 ".firstprivate.temp");
8542 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(),
8543 RefExpr->getExprLoc());
8544 AddInitializerToDecl(VDPrivate,
8545 DefaultLvalueConversion(VDInitRefExpr).get(),
8546 /*DirectInit=*/false, /*TypeMayContainAuto=*/false);
8548 if (VDPrivate->isInvalidDecl()) {
8549 if (IsImplicitClause) {
8550 Diag(RefExpr->getExprLoc(),
8551 diag::note_omp_task_predetermined_firstprivate_here);
8555 CurContext->addDecl(VDPrivate);
8556 auto VDPrivateRefExpr = buildDeclRefExpr(
8557 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(),
8558 RefExpr->getExprLoc());
8559 DeclRefExpr *Ref = nullptr;
8560 if (!VD && !CurContext->isDependentContext()) {
8561 if (TopDVar.CKind == OMPC_lastprivate)
8562 Ref = TopDVar.PrivateCopy;
8564 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8565 if (!IsOpenMPCapturedDecl(D))
8566 ExprCaptures.push_back(Ref->getDecl());
8569 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref);
8570 Vars.push_back((VD || CurContext->isDependentContext())
8571 ? RefExpr->IgnoreParens()
8573 PrivateCopies.push_back(VDPrivateRefExpr);
8574 Inits.push_back(VDInitRefExpr);
8580 return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8581 Vars, PrivateCopies, Inits,
8582 buildPreInits(Context, ExprCaptures));
8585 OMPClause *Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
8586 SourceLocation StartLoc,
8587 SourceLocation LParenLoc,
8588 SourceLocation EndLoc) {
8589 SmallVector<Expr *, 8> Vars;
8590 SmallVector<Expr *, 8> SrcExprs;
8591 SmallVector<Expr *, 8> DstExprs;
8592 SmallVector<Expr *, 8> AssignmentOps;
8593 SmallVector<Decl *, 4> ExprCaptures;
8594 SmallVector<Expr *, 4> ExprPostUpdates;
8595 for (auto &RefExpr : VarList) {
8596 assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8597 SourceLocation ELoc;
8599 Expr *SimpleRefExpr = RefExpr;
8600 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8602 // It will be analyzed later.
8603 Vars.push_back(RefExpr);
8604 SrcExprs.push_back(nullptr);
8605 DstExprs.push_back(nullptr);
8606 AssignmentOps.push_back(nullptr);
8608 ValueDecl *D = Res.first;
8612 QualType Type = D->getType();
8613 auto *VD = dyn_cast<VarDecl>(D);
8615 // OpenMP [2.14.3.5, Restrictions, C/C++, p.2]
8616 // A variable that appears in a lastprivate clause must not have an
8617 // incomplete type or a reference type.
8618 if (RequireCompleteType(ELoc, Type,
8619 diag::err_omp_lastprivate_incomplete_type))
8621 Type = Type.getNonReferenceType();
8623 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
8625 // Variables with the predetermined data-sharing attributes may not be
8626 // listed in data-sharing attributes clauses, except for the cases
8628 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8629 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_lastprivate &&
8630 DVar.CKind != OMPC_firstprivate &&
8631 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
8632 Diag(ELoc, diag::err_omp_wrong_dsa)
8633 << getOpenMPClauseName(DVar.CKind)
8634 << getOpenMPClauseName(OMPC_lastprivate);
8635 ReportOriginalDSA(*this, DSAStack, D, DVar);
8639 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8640 // OpenMP [2.14.3.5, Restrictions, p.2]
8641 // A list item that is private within a parallel region, or that appears in
8642 // the reduction clause of a parallel construct, must not appear in a
8643 // lastprivate clause on a worksharing construct if any of the corresponding
8644 // worksharing regions ever binds to any of the corresponding parallel
8646 DSAStackTy::DSAVarData TopDVar = DVar;
8647 if (isOpenMPWorksharingDirective(CurrDir) &&
8648 !isOpenMPParallelDirective(CurrDir)) {
8649 DVar = DSAStack->getImplicitDSA(D, true);
8650 if (DVar.CKind != OMPC_shared) {
8651 Diag(ELoc, diag::err_omp_required_access)
8652 << getOpenMPClauseName(OMPC_lastprivate)
8653 << getOpenMPClauseName(OMPC_shared);
8654 ReportOriginalDSA(*this, DSAStack, D, DVar);
8659 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
8660 // A list item may appear in a firstprivate or lastprivate clause but not
8662 if (CurrDir == OMPD_distribute) {
8663 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8664 if (DVar.CKind == OMPC_firstprivate) {
8665 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
8666 ReportOriginalDSA(*this, DSAStack, D, DVar);
8671 // OpenMP [2.14.3.5, Restrictions, C++, p.1,2]
8672 // A variable of class type (or array thereof) that appears in a
8673 // lastprivate clause requires an accessible, unambiguous default
8674 // constructor for the class type, unless the list item is also specified
8675 // in a firstprivate clause.
8676 // A variable of class type (or array thereof) that appears in a
8677 // lastprivate clause requires an accessible, unambiguous copy assignment
8678 // operator for the class type.
8679 Type = Context.getBaseElementType(Type).getNonReferenceType();
8680 auto *SrcVD = buildVarDecl(*this, ERange.getBegin(),
8681 Type.getUnqualifiedType(), ".lastprivate.src",
8682 D->hasAttrs() ? &D->getAttrs() : nullptr);
8683 auto *PseudoSrcExpr =
8684 buildDeclRefExpr(*this, SrcVD, Type.getUnqualifiedType(), ELoc);
8686 buildVarDecl(*this, ERange.getBegin(), Type, ".lastprivate.dst",
8687 D->hasAttrs() ? &D->getAttrs() : nullptr);
8688 auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc);
8689 // For arrays generate assignment operation for single element and replace
8690 // it by the original array element in CodeGen.
8691 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, ELoc, BO_Assign,
8692 PseudoDstExpr, PseudoSrcExpr);
8693 if (AssignmentOp.isInvalid())
8695 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
8696 /*DiscardedValue=*/true);
8697 if (AssignmentOp.isInvalid())
8700 DeclRefExpr *Ref = nullptr;
8701 if (!VD && !CurContext->isDependentContext()) {
8702 if (TopDVar.CKind == OMPC_firstprivate)
8703 Ref = TopDVar.PrivateCopy;
8705 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8706 if (!IsOpenMPCapturedDecl(D))
8707 ExprCaptures.push_back(Ref->getDecl());
8709 if (TopDVar.CKind == OMPC_firstprivate ||
8710 (!IsOpenMPCapturedDecl(D) &&
8711 Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>())) {
8712 ExprResult RefRes = DefaultLvalueConversion(Ref);
8713 if (!RefRes.isUsable())
8715 ExprResult PostUpdateRes =
8716 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, SimpleRefExpr,
8718 if (!PostUpdateRes.isUsable())
8720 ExprPostUpdates.push_back(
8721 IgnoredValueConversions(PostUpdateRes.get()).get());
8724 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_lastprivate, Ref);
8725 Vars.push_back((VD || CurContext->isDependentContext())
8726 ? RefExpr->IgnoreParens()
8728 SrcExprs.push_back(PseudoSrcExpr);
8729 DstExprs.push_back(PseudoDstExpr);
8730 AssignmentOps.push_back(AssignmentOp.get());
8736 return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8737 Vars, SrcExprs, DstExprs, AssignmentOps,
8738 buildPreInits(Context, ExprCaptures),
8739 buildPostUpdate(*this, ExprPostUpdates));
8742 OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
8743 SourceLocation StartLoc,
8744 SourceLocation LParenLoc,
8745 SourceLocation EndLoc) {
8746 SmallVector<Expr *, 8> Vars;
8747 for (auto &RefExpr : VarList) {
8748 assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8749 SourceLocation ELoc;
8751 Expr *SimpleRefExpr = RefExpr;
8752 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8754 // It will be analyzed later.
8755 Vars.push_back(RefExpr);
8757 ValueDecl *D = Res.first;
8761 auto *VD = dyn_cast<VarDecl>(D);
8762 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8764 // Variables with the predetermined data-sharing attributes may not be
8765 // listed in data-sharing attributes clauses, except for the cases
8766 // listed below. For these exceptions only, listing a predetermined
8767 // variable in a data-sharing attribute clause is allowed and overrides
8768 // the variable's predetermined data-sharing attributes.
8769 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8770 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared &&
8772 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8773 << getOpenMPClauseName(OMPC_shared);
8774 ReportOriginalDSA(*this, DSAStack, D, DVar);
8778 DeclRefExpr *Ref = nullptr;
8779 if (!VD && IsOpenMPCapturedDecl(D) && !CurContext->isDependentContext())
8780 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8781 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_shared, Ref);
8782 Vars.push_back((VD || !Ref || CurContext->isDependentContext())
8783 ? RefExpr->IgnoreParens()
8790 return OMPSharedClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars);
8794 class DSARefChecker : public StmtVisitor<DSARefChecker, bool> {
8798 bool VisitDeclRefExpr(DeclRefExpr *E) {
8799 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) {
8800 DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, false);
8801 if (DVar.CKind == OMPC_shared && !DVar.RefExpr)
8803 if (DVar.CKind != OMPC_unknown)
8805 DSAStackTy::DSAVarData DVarPrivate = Stack->hasDSA(
8806 VD, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
8808 if (DVarPrivate.CKind != OMPC_unknown)
8814 bool VisitStmt(Stmt *S) {
8815 for (auto Child : S->children()) {
8816 if (Child && Visit(Child))
8821 explicit DSARefChecker(DSAStackTy *S) : Stack(S) {}
8826 // Transform MemberExpression for specified FieldDecl of current class to
8827 // DeclRefExpr to specified OMPCapturedExprDecl.
8828 class TransformExprToCaptures : public TreeTransform<TransformExprToCaptures> {
8829 typedef TreeTransform<TransformExprToCaptures> BaseTransform;
8831 DeclRefExpr *CapturedExpr;
8834 TransformExprToCaptures(Sema &SemaRef, ValueDecl *FieldDecl)
8835 : BaseTransform(SemaRef), Field(FieldDecl), CapturedExpr(nullptr) {}
8837 ExprResult TransformMemberExpr(MemberExpr *E) {
8838 if (isa<CXXThisExpr>(E->getBase()->IgnoreParenImpCasts()) &&
8839 E->getMemberDecl() == Field) {
8840 CapturedExpr = buildCapture(SemaRef, Field, E, /*WithInit=*/false);
8841 return CapturedExpr;
8843 return BaseTransform::TransformMemberExpr(E);
8845 DeclRefExpr *getCapturedExpr() { return CapturedExpr; }
8849 template <typename T>
8850 static T filterLookupForUDR(SmallVectorImpl<UnresolvedSet<8>> &Lookups,
8851 const llvm::function_ref<T(ValueDecl *)> &Gen) {
8852 for (auto &Set : Lookups) {
8853 for (auto *D : Set) {
8854 if (auto Res = Gen(cast<ValueDecl>(D)))
8862 buildDeclareReductionRef(Sema &SemaRef, SourceLocation Loc, SourceRange Range,
8863 Scope *S, CXXScopeSpec &ReductionIdScopeSpec,
8864 const DeclarationNameInfo &ReductionId, QualType Ty,
8865 CXXCastPath &BasePath, Expr *UnresolvedReduction) {
8866 if (ReductionIdScopeSpec.isInvalid())
8868 SmallVector<UnresolvedSet<8>, 4> Lookups;
8870 LookupResult Lookup(SemaRef, ReductionId, Sema::LookupOMPReductionName);
8871 Lookup.suppressDiagnostics();
8872 while (S && SemaRef.LookupParsedName(Lookup, S, &ReductionIdScopeSpec)) {
8873 auto *D = Lookup.getRepresentativeDecl();
8876 } while (S && !S->isDeclScope(D));
8879 Lookups.push_back(UnresolvedSet<8>());
8880 Lookups.back().append(Lookup.begin(), Lookup.end());
8883 } else if (auto *ULE =
8884 cast_or_null<UnresolvedLookupExpr>(UnresolvedReduction)) {
8885 Lookups.push_back(UnresolvedSet<8>());
8886 Decl *PrevD = nullptr;
8887 for(auto *D : ULE->decls()) {
8889 Lookups.push_back(UnresolvedSet<8>());
8890 else if (auto *DRD = cast<OMPDeclareReductionDecl>(D))
8891 Lookups.back().addDecl(DRD);
8895 if (Ty->isDependentType() || Ty->isInstantiationDependentType() ||
8896 Ty->containsUnexpandedParameterPack() ||
8897 filterLookupForUDR<bool>(Lookups, [](ValueDecl *D) -> bool {
8898 return !D->isInvalidDecl() &&
8899 (D->getType()->isDependentType() ||
8900 D->getType()->isInstantiationDependentType() ||
8901 D->getType()->containsUnexpandedParameterPack());
8903 UnresolvedSet<8> ResSet;
8904 for (auto &Set : Lookups) {
8905 ResSet.append(Set.begin(), Set.end());
8906 // The last item marks the end of all declarations at the specified scope.
8907 ResSet.addDecl(Set[Set.size() - 1]);
8909 return UnresolvedLookupExpr::Create(
8910 SemaRef.Context, /*NamingClass=*/nullptr,
8911 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), ReductionId,
8912 /*ADL=*/true, /*Overloaded=*/true, ResSet.begin(), ResSet.end());
8914 if (auto *VD = filterLookupForUDR<ValueDecl *>(
8915 Lookups, [&SemaRef, Ty](ValueDecl *D) -> ValueDecl * {
8916 if (!D->isInvalidDecl() &&
8917 SemaRef.Context.hasSameType(D->getType(), Ty))
8921 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8922 if (auto *VD = filterLookupForUDR<ValueDecl *>(
8923 Lookups, [&SemaRef, Ty, Loc](ValueDecl *D) -> ValueDecl * {
8924 if (!D->isInvalidDecl() &&
8925 SemaRef.IsDerivedFrom(Loc, Ty, D->getType()) &&
8926 !Ty.isMoreQualifiedThan(D->getType()))
8930 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
8931 /*DetectVirtual=*/false);
8932 if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) {
8933 if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType(
8934 VD->getType().getUnqualifiedType()))) {
8935 if (SemaRef.CheckBaseClassAccess(Loc, VD->getType(), Ty, Paths.front(),
8937 Sema::AR_inaccessible) {
8938 SemaRef.BuildBasePathArray(Paths, BasePath);
8939 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8944 if (ReductionIdScopeSpec.isSet()) {
8945 SemaRef.Diag(Loc, diag::err_omp_not_resolved_reduction_identifier) << Range;
8951 OMPClause *Sema::ActOnOpenMPReductionClause(
8952 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
8953 SourceLocation ColonLoc, SourceLocation EndLoc,
8954 CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId,
8955 ArrayRef<Expr *> UnresolvedReductions) {
8956 auto DN = ReductionId.getName();
8957 auto OOK = DN.getCXXOverloadedOperator();
8958 BinaryOperatorKind BOK = BO_Comma;
8960 // OpenMP [2.14.3.6, reduction clause]
8962 // reduction-identifier is either an identifier or one of the following
8963 // operators: +, -, *, &, |, ^, && and ||
8965 // reduction-identifier is either an id-expression or one of the following
8966 // operators: +, -, *, &, |, ^, && and ||
8967 // FIXME: Only 'min' and 'max' identifiers are supported for now.
8994 case OO_Array_Delete:
9003 case OO_GreaterEqual:
9008 case OO_PercentEqual:
9013 case OO_GreaterGreater:
9014 case OO_LessLessEqual:
9015 case OO_GreaterGreaterEqual:
9017 case OO_ExclaimEqual:
9025 case OO_Conditional:
9027 case NUM_OVERLOADED_OPERATORS:
9028 llvm_unreachable("Unexpected reduction identifier");
9030 if (auto II = DN.getAsIdentifierInfo()) {
9031 if (II->isStr("max"))
9033 else if (II->isStr("min"))
9038 SourceRange ReductionIdRange;
9039 if (ReductionIdScopeSpec.isValid())
9040 ReductionIdRange.setBegin(ReductionIdScopeSpec.getBeginLoc());
9041 ReductionIdRange.setEnd(ReductionId.getEndLoc());
9043 SmallVector<Expr *, 8> Vars;
9044 SmallVector<Expr *, 8> Privates;
9045 SmallVector<Expr *, 8> LHSs;
9046 SmallVector<Expr *, 8> RHSs;
9047 SmallVector<Expr *, 8> ReductionOps;
9048 SmallVector<Decl *, 4> ExprCaptures;
9049 SmallVector<Expr *, 4> ExprPostUpdates;
9050 auto IR = UnresolvedReductions.begin(), ER = UnresolvedReductions.end();
9051 bool FirstIter = true;
9052 for (auto RefExpr : VarList) {
9053 assert(RefExpr && "nullptr expr in OpenMP reduction clause.");
9054 // OpenMP [2.1, C/C++]
9055 // A list item is a variable or array section, subject to the restrictions
9056 // specified in Section 2.4 on page 42 and in each of the sections
9057 // describing clauses and directives for which a list appears.
9058 // OpenMP [2.14.3.3, Restrictions, p.1]
9059 // A variable that is part of another variable (as an array or
9060 // structure element) cannot appear in a private clause.
9061 if (!FirstIter && IR != ER)
9064 SourceLocation ELoc;
9066 Expr *SimpleRefExpr = RefExpr;
9067 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9068 /*AllowArraySection=*/true);
9070 // It will be analyzed later.
9071 Vars.push_back(RefExpr);
9072 Privates.push_back(nullptr);
9073 LHSs.push_back(nullptr);
9074 RHSs.push_back(nullptr);
9075 // Try to find 'declare reduction' corresponding construct before using
9076 // builtin/overloaded operators.
9077 QualType Type = Context.DependentTy;
9078 CXXCastPath BasePath;
9079 ExprResult DeclareReductionRef = buildDeclareReductionRef(
9080 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
9081 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
9082 if (CurContext->isDependentContext() &&
9083 (DeclareReductionRef.isUnset() ||
9084 isa<UnresolvedLookupExpr>(DeclareReductionRef.get())))
9085 ReductionOps.push_back(DeclareReductionRef.get());
9087 ReductionOps.push_back(nullptr);
9089 ValueDecl *D = Res.first;
9094 auto *ASE = dyn_cast<ArraySubscriptExpr>(RefExpr->IgnoreParens());
9095 auto *OASE = dyn_cast<OMPArraySectionExpr>(RefExpr->IgnoreParens());
9097 Type = ASE->getType().getNonReferenceType();
9099 auto BaseType = OMPArraySectionExpr::getBaseOriginalType(OASE->getBase());
9100 if (auto *ATy = BaseType->getAsArrayTypeUnsafe())
9101 Type = ATy->getElementType();
9103 Type = BaseType->getPointeeType();
9104 Type = Type.getNonReferenceType();
9106 Type = Context.getBaseElementType(D->getType().getNonReferenceType());
9107 auto *VD = dyn_cast<VarDecl>(D);
9109 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
9110 // A variable that appears in a private clause must not have an incomplete
9111 // type or a reference type.
9112 if (RequireCompleteType(ELoc, Type,
9113 diag::err_omp_reduction_incomplete_type))
9115 // OpenMP [2.14.3.6, reduction clause, Restrictions]
9116 // A list item that appears in a reduction clause must not be
9118 if (Type.getNonReferenceType().isConstant(Context)) {
9119 Diag(ELoc, diag::err_omp_const_reduction_list_item)
9120 << getOpenMPClauseName(OMPC_reduction) << Type << ERange;
9121 if (!ASE && !OASE) {
9122 bool IsDecl = !VD ||
9123 VD->isThisDeclarationADefinition(Context) ==
9124 VarDecl::DeclarationOnly;
9125 Diag(D->getLocation(),
9126 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9131 // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]
9132 // If a list-item is a reference type then it must bind to the same object
9133 // for all threads of the team.
9134 if (!ASE && !OASE && VD) {
9135 VarDecl *VDDef = VD->getDefinition();
9136 if (VD->getType()->isReferenceType() && VDDef && VDDef->hasInit()) {
9137 DSARefChecker Check(DSAStack);
9138 if (Check.Visit(VDDef->getInit())) {
9139 Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange;
9140 Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
9146 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
9148 // Variables with the predetermined data-sharing attributes may not be
9149 // listed in data-sharing attributes clauses, except for the cases
9150 // listed below. For these exceptions only, listing a predetermined
9151 // variable in a data-sharing attribute clause is allowed and overrides
9152 // the variable's predetermined data-sharing attributes.
9153 // OpenMP [2.14.3.6, Restrictions, p.3]
9154 // Any number of reduction clauses can be specified on the directive,
9155 // but a list item can appear only once in the reduction clauses for that
9157 DSAStackTy::DSAVarData DVar;
9158 DVar = DSAStack->getTopDSA(D, false);
9159 if (DVar.CKind == OMPC_reduction) {
9160 Diag(ELoc, diag::err_omp_once_referenced)
9161 << getOpenMPClauseName(OMPC_reduction);
9163 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);
9164 } else if (DVar.CKind != OMPC_unknown) {
9165 Diag(ELoc, diag::err_omp_wrong_dsa)
9166 << getOpenMPClauseName(DVar.CKind)
9167 << getOpenMPClauseName(OMPC_reduction);
9168 ReportOriginalDSA(*this, DSAStack, D, DVar);
9172 // OpenMP [2.14.3.6, Restrictions, p.1]
9173 // A list item that appears in a reduction clause of a worksharing
9174 // construct must be shared in the parallel regions to which any of the
9175 // worksharing regions arising from the worksharing construct bind.
9176 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
9177 if (isOpenMPWorksharingDirective(CurrDir) &&
9178 !isOpenMPParallelDirective(CurrDir)) {
9179 DVar = DSAStack->getImplicitDSA(D, true);
9180 if (DVar.CKind != OMPC_shared) {
9181 Diag(ELoc, diag::err_omp_required_access)
9182 << getOpenMPClauseName(OMPC_reduction)
9183 << getOpenMPClauseName(OMPC_shared);
9184 ReportOriginalDSA(*this, DSAStack, D, DVar);
9189 // Try to find 'declare reduction' corresponding construct before using
9190 // builtin/overloaded operators.
9191 CXXCastPath BasePath;
9192 ExprResult DeclareReductionRef = buildDeclareReductionRef(
9193 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
9194 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
9195 if (DeclareReductionRef.isInvalid())
9197 if (CurContext->isDependentContext() &&
9198 (DeclareReductionRef.isUnset() ||
9199 isa<UnresolvedLookupExpr>(DeclareReductionRef.get()))) {
9200 Vars.push_back(RefExpr);
9201 Privates.push_back(nullptr);
9202 LHSs.push_back(nullptr);
9203 RHSs.push_back(nullptr);
9204 ReductionOps.push_back(DeclareReductionRef.get());
9207 if (BOK == BO_Comma && DeclareReductionRef.isUnset()) {
9208 // Not allowed reduction identifier is found.
9209 Diag(ReductionId.getLocStart(),
9210 diag::err_omp_unknown_reduction_identifier)
9211 << Type << ReductionIdRange;
9215 // OpenMP [2.14.3.6, reduction clause, Restrictions]
9216 // The type of a list item that appears in a reduction clause must be valid
9217 // for the reduction-identifier. For a max or min reduction in C, the type
9218 // of the list item must be an allowed arithmetic data type: char, int,
9219 // float, double, or _Bool, possibly modified with long, short, signed, or
9220 // unsigned. For a max or min reduction in C++, the type of the list item
9221 // must be an allowed arithmetic data type: char, wchar_t, int, float,
9222 // double, or bool, possibly modified with long, short, signed, or unsigned.
9223 if (DeclareReductionRef.isUnset()) {
9224 if ((BOK == BO_GT || BOK == BO_LT) &&
9225 !(Type->isScalarType() ||
9226 (getLangOpts().CPlusPlus && Type->isArithmeticType()))) {
9227 Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg)
9228 << getLangOpts().CPlusPlus;
9229 if (!ASE && !OASE) {
9230 bool IsDecl = !VD ||
9231 VD->isThisDeclarationADefinition(Context) ==
9232 VarDecl::DeclarationOnly;
9233 Diag(D->getLocation(),
9234 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9239 if ((BOK == BO_OrAssign || BOK == BO_AndAssign || BOK == BO_XorAssign) &&
9240 !getLangOpts().CPlusPlus && Type->isFloatingType()) {
9241 Diag(ELoc, diag::err_omp_clause_floating_type_arg);
9242 if (!ASE && !OASE) {
9243 bool IsDecl = !VD ||
9244 VD->isThisDeclarationADefinition(Context) ==
9245 VarDecl::DeclarationOnly;
9246 Diag(D->getLocation(),
9247 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9254 Type = Type.getNonLValueExprType(Context).getUnqualifiedType();
9255 auto *LHSVD = buildVarDecl(*this, ELoc, Type, ".reduction.lhs",
9256 D->hasAttrs() ? &D->getAttrs() : nullptr);
9257 auto *RHSVD = buildVarDecl(*this, ELoc, Type, D->getName(),
9258 D->hasAttrs() ? &D->getAttrs() : nullptr);
9259 auto PrivateTy = Type;
9262 D->getType().getNonReferenceType()->isVariablyModifiedType())) {
9263 // For arays/array sections only:
9264 // Create pseudo array type for private copy. The size for this array will
9265 // be generated during codegen.
9266 // For array subscripts or single variables Private Ty is the same as Type
9267 // (type of the variable or single array element).
9268 PrivateTy = Context.getVariableArrayType(
9269 Type, new (Context) OpaqueValueExpr(SourceLocation(),
9270 Context.getSizeType(), VK_RValue),
9271 ArrayType::Normal, /*IndexTypeQuals=*/0, SourceRange());
9272 } else if (!ASE && !OASE &&
9273 Context.getAsArrayType(D->getType().getNonReferenceType()))
9274 PrivateTy = D->getType().getNonReferenceType();
9276 auto *PrivateVD = buildVarDecl(*this, ELoc, PrivateTy, D->getName(),
9277 D->hasAttrs() ? &D->getAttrs() : nullptr);
9278 // Add initializer for private variable.
9279 Expr *Init = nullptr;
9280 auto *LHSDRE = buildDeclRefExpr(*this, LHSVD, Type, ELoc);
9281 auto *RHSDRE = buildDeclRefExpr(*this, RHSVD, Type, ELoc);
9282 if (DeclareReductionRef.isUsable()) {
9283 auto *DRDRef = DeclareReductionRef.getAs<DeclRefExpr>();
9284 auto *DRD = cast<OMPDeclareReductionDecl>(DRDRef->getDecl());
9285 if (DRD->getInitializer()) {
9287 RHSVD->setInit(DRDRef);
9288 RHSVD->setInitStyle(VarDecl::CallInit);
9296 // '+', '-', '^', '|', '||' reduction ops - initializer is '0'.
9297 if (Type->isScalarType() || Type->isAnyComplexType())
9298 Init = ActOnIntegerConstant(ELoc, /*Val=*/0).get();
9302 if (Type->isScalarType() || Type->isAnyComplexType()) {
9303 // '*' and '&&' reduction ops - initializer is '1'.
9304 Init = ActOnIntegerConstant(ELoc, /*Val=*/1).get();
9308 // '&' reduction op - initializer is '~0'.
9309 QualType OrigType = Type;
9310 if (auto *ComplexTy = OrigType->getAs<ComplexType>())
9311 Type = ComplexTy->getElementType();
9312 if (Type->isRealFloatingType()) {
9313 llvm::APFloat InitValue =
9314 llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type),
9316 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
9318 } else if (Type->isScalarType()) {
9319 auto Size = Context.getTypeSize(Type);
9320 QualType IntTy = Context.getIntTypeForBitwidth(Size, /*Signed=*/0);
9321 llvm::APInt InitValue = llvm::APInt::getAllOnesValue(Size);
9322 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
9324 if (Init && OrigType->isAnyComplexType()) {
9325 // Init = 0xFFFF + 0xFFFFi;
9326 auto *Im = new (Context) ImaginaryLiteral(Init, OrigType);
9327 Init = CreateBuiltinBinOp(ELoc, BO_Add, Init, Im).get();
9334 // 'min' reduction op - initializer is 'Largest representable number in
9335 // the reduction list item type'.
9336 // 'max' reduction op - initializer is 'Least representable number in
9337 // the reduction list item type'.
9338 if (Type->isIntegerType() || Type->isPointerType()) {
9339 bool IsSigned = Type->hasSignedIntegerRepresentation();
9340 auto Size = Context.getTypeSize(Type);
9342 Context.getIntTypeForBitwidth(Size, /*Signed=*/IsSigned);
9343 llvm::APInt InitValue =
9345 ? IsSigned ? llvm::APInt::getSignedMinValue(Size)
9346 : llvm::APInt::getMinValue(Size)
9347 : IsSigned ? llvm::APInt::getSignedMaxValue(Size)
9348 : llvm::APInt::getMaxValue(Size);
9349 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
9350 if (Type->isPointerType()) {
9351 // Cast to pointer type.
9352 auto CastExpr = BuildCStyleCastExpr(
9353 SourceLocation(), Context.getTrivialTypeSourceInfo(Type, ELoc),
9354 SourceLocation(), Init);
9355 if (CastExpr.isInvalid())
9357 Init = CastExpr.get();
9359 } else if (Type->isRealFloatingType()) {
9360 llvm::APFloat InitValue = llvm::APFloat::getLargest(
9361 Context.getFloatTypeSemantics(Type), BOK != BO_LT);
9362 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
9390 llvm_unreachable("Unexpected reduction operation");
9393 if (Init && DeclareReductionRef.isUnset()) {
9394 AddInitializerToDecl(RHSVD, Init, /*DirectInit=*/false,
9395 /*TypeMayContainAuto=*/false);
9397 ActOnUninitializedDecl(RHSVD, /*TypeMayContainAuto=*/false);
9398 if (RHSVD->isInvalidDecl())
9400 if (!RHSVD->hasInit() && DeclareReductionRef.isUnset()) {
9401 Diag(ELoc, diag::err_omp_reduction_id_not_compatible) << Type
9402 << ReductionIdRange;
9405 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9406 Diag(D->getLocation(),
9407 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9411 // Store initializer for single element in private copy. Will be used during
9413 PrivateVD->setInit(RHSVD->getInit());
9414 PrivateVD->setInitStyle(RHSVD->getInitStyle());
9415 auto *PrivateDRE = buildDeclRefExpr(*this, PrivateVD, PrivateTy, ELoc);
9416 ExprResult ReductionOp;
9417 if (DeclareReductionRef.isUsable()) {
9418 QualType RedTy = DeclareReductionRef.get()->getType();
9419 QualType PtrRedTy = Context.getPointerType(RedTy);
9420 ExprResult LHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, LHSDRE);
9421 ExprResult RHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, RHSDRE);
9422 if (!BasePath.empty()) {
9423 LHS = DefaultLvalueConversion(LHS.get());
9424 RHS = DefaultLvalueConversion(RHS.get());
9425 LHS = ImplicitCastExpr::Create(Context, PtrRedTy,
9426 CK_UncheckedDerivedToBase, LHS.get(),
9427 &BasePath, LHS.get()->getValueKind());
9428 RHS = ImplicitCastExpr::Create(Context, PtrRedTy,
9429 CK_UncheckedDerivedToBase, RHS.get(),
9430 &BasePath, RHS.get()->getValueKind());
9432 FunctionProtoType::ExtProtoInfo EPI;
9433 QualType Params[] = {PtrRedTy, PtrRedTy};
9434 QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
9435 auto *OVE = new (Context) OpaqueValueExpr(
9436 ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
9437 DefaultLvalueConversion(DeclareReductionRef.get()).get());
9438 Expr *Args[] = {LHS.get(), RHS.get()};
9439 ReductionOp = new (Context)
9440 CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
9442 ReductionOp = BuildBinOp(DSAStack->getCurScope(),
9443 ReductionId.getLocStart(), BOK, LHSDRE, RHSDRE);
9444 if (ReductionOp.isUsable()) {
9445 if (BOK != BO_LT && BOK != BO_GT) {
9447 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
9448 BO_Assign, LHSDRE, ReductionOp.get());
9450 auto *ConditionalOp = new (Context) ConditionalOperator(
9451 ReductionOp.get(), SourceLocation(), LHSDRE, SourceLocation(),
9452 RHSDRE, Type, VK_LValue, OK_Ordinary);
9454 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
9455 BO_Assign, LHSDRE, ConditionalOp);
9457 ReductionOp = ActOnFinishFullExpr(ReductionOp.get());
9459 if (ReductionOp.isInvalid())
9463 DeclRefExpr *Ref = nullptr;
9464 Expr *VarsExpr = RefExpr->IgnoreParens();
9465 if (!VD && !CurContext->isDependentContext()) {
9467 TransformExprToCaptures RebuildToCapture(*this, D);
9469 RebuildToCapture.TransformExpr(RefExpr->IgnoreParens()).get();
9470 Ref = RebuildToCapture.getCapturedExpr();
9473 buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
9475 if (!IsOpenMPCapturedDecl(D)) {
9476 ExprCaptures.push_back(Ref->getDecl());
9477 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
9478 ExprResult RefRes = DefaultLvalueConversion(Ref);
9479 if (!RefRes.isUsable())
9481 ExprResult PostUpdateRes =
9482 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9483 SimpleRefExpr, RefRes.get());
9484 if (!PostUpdateRes.isUsable())
9486 ExprPostUpdates.push_back(
9487 IgnoredValueConversions(PostUpdateRes.get()).get());
9491 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_reduction, Ref);
9492 Vars.push_back(VarsExpr);
9493 Privates.push_back(PrivateDRE);
9494 LHSs.push_back(LHSDRE);
9495 RHSs.push_back(RHSDRE);
9496 ReductionOps.push_back(ReductionOp.get());
9502 return OMPReductionClause::Create(
9503 Context, StartLoc, LParenLoc, ColonLoc, EndLoc, Vars,
9504 ReductionIdScopeSpec.getWithLocInContext(Context), ReductionId, Privates,
9505 LHSs, RHSs, ReductionOps, buildPreInits(Context, ExprCaptures),
9506 buildPostUpdate(*this, ExprPostUpdates));
9509 bool Sema::CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
9510 SourceLocation LinLoc) {
9511 if ((!LangOpts.CPlusPlus && LinKind != OMPC_LINEAR_val) ||
9512 LinKind == OMPC_LINEAR_unknown) {
9513 Diag(LinLoc, diag::err_omp_wrong_linear_modifier) << LangOpts.CPlusPlus;
9519 bool Sema::CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc,
9520 OpenMPLinearClauseKind LinKind,
9522 auto *VD = dyn_cast_or_null<VarDecl>(D);
9523 // A variable must not have an incomplete type or a reference type.
9524 if (RequireCompleteType(ELoc, Type, diag::err_omp_linear_incomplete_type))
9526 if ((LinKind == OMPC_LINEAR_uval || LinKind == OMPC_LINEAR_ref) &&
9527 !Type->isReferenceType()) {
9528 Diag(ELoc, diag::err_omp_wrong_linear_modifier_non_reference)
9529 << Type << getOpenMPSimpleClauseTypeName(OMPC_linear, LinKind);
9532 Type = Type.getNonReferenceType();
9534 // A list item must not be const-qualified.
9535 if (Type.isConstant(Context)) {
9536 Diag(ELoc, diag::err_omp_const_variable)
9537 << getOpenMPClauseName(OMPC_linear);
9541 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9542 Diag(D->getLocation(),
9543 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9549 // A list item must be of integral or pointer type.
9550 Type = Type.getUnqualifiedType().getCanonicalType();
9551 const auto *Ty = Type.getTypePtrOrNull();
9552 if (!Ty || (!Ty->isDependentType() && !Ty->isIntegralType(Context) &&
9553 !Ty->isPointerType())) {
9554 Diag(ELoc, diag::err_omp_linear_expected_int_or_ptr) << Type;
9558 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9559 Diag(D->getLocation(),
9560 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9568 OMPClause *Sema::ActOnOpenMPLinearClause(
9569 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
9570 SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind,
9571 SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9572 SmallVector<Expr *, 8> Vars;
9573 SmallVector<Expr *, 8> Privates;
9574 SmallVector<Expr *, 8> Inits;
9575 SmallVector<Decl *, 4> ExprCaptures;
9576 SmallVector<Expr *, 4> ExprPostUpdates;
9577 if (CheckOpenMPLinearModifier(LinKind, LinLoc))
9578 LinKind = OMPC_LINEAR_val;
9579 for (auto &RefExpr : VarList) {
9580 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9581 SourceLocation ELoc;
9583 Expr *SimpleRefExpr = RefExpr;
9584 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9585 /*AllowArraySection=*/false);
9587 // It will be analyzed later.
9588 Vars.push_back(RefExpr);
9589 Privates.push_back(nullptr);
9590 Inits.push_back(nullptr);
9592 ValueDecl *D = Res.first;
9596 QualType Type = D->getType();
9597 auto *VD = dyn_cast<VarDecl>(D);
9599 // OpenMP [2.14.3.7, linear clause]
9600 // A list-item cannot appear in more than one linear clause.
9601 // A list-item that appears in a linear clause cannot appear in any
9602 // other data-sharing attribute clause.
9603 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
9605 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
9606 << getOpenMPClauseName(OMPC_linear);
9607 ReportOriginalDSA(*this, DSAStack, D, DVar);
9611 if (CheckOpenMPLinearDecl(D, ELoc, LinKind, Type))
9613 Type = Type.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9615 // Build private copy of original var.
9616 auto *Private = buildVarDecl(*this, ELoc, Type, D->getName(),
9617 D->hasAttrs() ? &D->getAttrs() : nullptr);
9618 auto *PrivateRef = buildDeclRefExpr(*this, Private, Type, ELoc);
9619 // Build var to save initial value.
9620 VarDecl *Init = buildVarDecl(*this, ELoc, Type, ".linear.start");
9622 DeclRefExpr *Ref = nullptr;
9623 if (!VD && !CurContext->isDependentContext()) {
9624 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
9625 if (!IsOpenMPCapturedDecl(D)) {
9626 ExprCaptures.push_back(Ref->getDecl());
9627 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
9628 ExprResult RefRes = DefaultLvalueConversion(Ref);
9629 if (!RefRes.isUsable())
9631 ExprResult PostUpdateRes =
9632 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9633 SimpleRefExpr, RefRes.get());
9634 if (!PostUpdateRes.isUsable())
9636 ExprPostUpdates.push_back(
9637 IgnoredValueConversions(PostUpdateRes.get()).get());
9641 if (LinKind == OMPC_LINEAR_uval)
9642 InitExpr = VD ? VD->getInit() : SimpleRefExpr;
9644 InitExpr = VD ? SimpleRefExpr : Ref;
9645 AddInitializerToDecl(Init, DefaultLvalueConversion(InitExpr).get(),
9646 /*DirectInit=*/false, /*TypeMayContainAuto=*/false);
9647 auto InitRef = buildDeclRefExpr(*this, Init, Type, ELoc);
9649 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_linear, Ref);
9650 Vars.push_back((VD || CurContext->isDependentContext())
9651 ? RefExpr->IgnoreParens()
9653 Privates.push_back(PrivateRef);
9654 Inits.push_back(InitRef);
9660 Expr *StepExpr = Step;
9661 Expr *CalcStepExpr = nullptr;
9662 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
9663 !Step->isInstantiationDependent() &&
9664 !Step->containsUnexpandedParameterPack()) {
9665 SourceLocation StepLoc = Step->getLocStart();
9666 ExprResult Val = PerformOpenMPImplicitIntegerConversion(StepLoc, Step);
9667 if (Val.isInvalid())
9669 StepExpr = Val.get();
9671 // Build var to save the step value.
9673 buildVarDecl(*this, StepLoc, StepExpr->getType(), ".linear.step");
9674 ExprResult SaveRef =
9675 buildDeclRefExpr(*this, SaveVar, StepExpr->getType(), StepLoc);
9676 ExprResult CalcStep =
9677 BuildBinOp(CurScope, StepLoc, BO_Assign, SaveRef.get(), StepExpr);
9678 CalcStep = ActOnFinishFullExpr(CalcStep.get());
9680 // Warn about zero linear step (it would be probably better specified as
9681 // making corresponding variables 'const').
9682 llvm::APSInt Result;
9683 bool IsConstant = StepExpr->isIntegerConstantExpr(Result, Context);
9684 if (IsConstant && !Result.isNegative() && !Result.isStrictlyPositive())
9685 Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0]
9686 << (Vars.size() > 1);
9687 if (!IsConstant && CalcStep.isUsable()) {
9688 // Calculate the step beforehand instead of doing this on each iteration.
9689 // (This is not used if the number of iterations may be kfold-ed).
9690 CalcStepExpr = CalcStep.get();
9694 return OMPLinearClause::Create(Context, StartLoc, LParenLoc, LinKind, LinLoc,
9695 ColonLoc, EndLoc, Vars, Privates, Inits,
9696 StepExpr, CalcStepExpr,
9697 buildPreInits(Context, ExprCaptures),
9698 buildPostUpdate(*this, ExprPostUpdates));
9701 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
9702 Expr *NumIterations, Sema &SemaRef,
9703 Scope *S, DSAStackTy *Stack) {
9704 // Walk the vars and build update/final expressions for the CodeGen.
9705 SmallVector<Expr *, 8> Updates;
9706 SmallVector<Expr *, 8> Finals;
9707 Expr *Step = Clause.getStep();
9708 Expr *CalcStep = Clause.getCalcStep();
9709 // OpenMP [2.14.3.7, linear clause]
9710 // If linear-step is not specified it is assumed to be 1.
9711 if (Step == nullptr)
9712 Step = SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get();
9713 else if (CalcStep) {
9714 Step = cast<BinaryOperator>(CalcStep)->getLHS();
9716 bool HasErrors = false;
9717 auto CurInit = Clause.inits().begin();
9718 auto CurPrivate = Clause.privates().begin();
9719 auto LinKind = Clause.getModifier();
9720 for (auto &RefExpr : Clause.varlists()) {
9721 SourceLocation ELoc;
9723 Expr *SimpleRefExpr = RefExpr;
9724 auto Res = getPrivateItem(SemaRef, SimpleRefExpr, ELoc, ERange,
9725 /*AllowArraySection=*/false);
9726 ValueDecl *D = Res.first;
9727 if (Res.second || !D) {
9728 Updates.push_back(nullptr);
9729 Finals.push_back(nullptr);
9733 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(D)) {
9734 D = cast<MemberExpr>(CED->getInit()->IgnoreParenImpCasts())
9737 auto &&Info = Stack->isLoopControlVariable(D);
9738 Expr *InitExpr = *CurInit;
9740 // Build privatized reference to the current linear var.
9741 auto DE = cast<DeclRefExpr>(SimpleRefExpr);
9743 if (LinKind == OMPC_LINEAR_uval)
9744 CapturedRef = cast<VarDecl>(DE->getDecl())->getInit();
9747 buildDeclRefExpr(SemaRef, cast<VarDecl>(DE->getDecl()),
9748 DE->getType().getUnqualifiedType(), DE->getExprLoc(),
9749 /*RefersToCapture=*/true);
9751 // Build update: Var = InitExpr + IV * Step
9755 BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), *CurPrivate,
9756 InitExpr, IV, Step, /* Subtract */ false);
9758 Update = *CurPrivate;
9759 Update = SemaRef.ActOnFinishFullExpr(Update.get(), DE->getLocStart(),
9760 /*DiscardedValue=*/true);
9762 // Build final: Var = InitExpr + NumIterations * Step
9765 Final = BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), CapturedRef,
9766 InitExpr, NumIterations, Step,
9767 /* Subtract */ false);
9769 Final = *CurPrivate;
9770 Final = SemaRef.ActOnFinishFullExpr(Final.get(), DE->getLocStart(),
9771 /*DiscardedValue=*/true);
9773 if (!Update.isUsable() || !Final.isUsable()) {
9774 Updates.push_back(nullptr);
9775 Finals.push_back(nullptr);
9778 Updates.push_back(Update.get());
9779 Finals.push_back(Final.get());
9784 Clause.setUpdates(Updates);
9785 Clause.setFinals(Finals);
9789 OMPClause *Sema::ActOnOpenMPAlignedClause(
9790 ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
9791 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9793 SmallVector<Expr *, 8> Vars;
9794 for (auto &RefExpr : VarList) {
9795 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9796 SourceLocation ELoc;
9798 Expr *SimpleRefExpr = RefExpr;
9799 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9800 /*AllowArraySection=*/false);
9802 // It will be analyzed later.
9803 Vars.push_back(RefExpr);
9805 ValueDecl *D = Res.first;
9809 QualType QType = D->getType();
9810 auto *VD = dyn_cast<VarDecl>(D);
9812 // OpenMP [2.8.1, simd construct, Restrictions]
9813 // The type of list items appearing in the aligned clause must be
9814 // array, pointer, reference to array, or reference to pointer.
9815 QType = QType.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9816 const Type *Ty = QType.getTypePtrOrNull();
9817 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
9818 Diag(ELoc, diag::err_omp_aligned_expected_array_or_ptr)
9819 << QType << getLangOpts().CPlusPlus << ERange;
9822 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9823 Diag(D->getLocation(),
9824 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9829 // OpenMP [2.8.1, simd construct, Restrictions]
9830 // A list-item cannot appear in more than one aligned clause.
9831 if (Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) {
9832 Diag(ELoc, diag::err_omp_aligned_twice) << 0 << ERange;
9833 Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa)
9834 << getOpenMPClauseName(OMPC_aligned);
9838 DeclRefExpr *Ref = nullptr;
9839 if (!VD && IsOpenMPCapturedDecl(D))
9840 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
9841 Vars.push_back(DefaultFunctionArrayConversion(
9842 (VD || !Ref) ? RefExpr->IgnoreParens() : Ref)
9846 // OpenMP [2.8.1, simd construct, Description]
9847 // The parameter of the aligned clause, alignment, must be a constant
9848 // positive integer expression.
9849 // If no optional parameter is specified, implementation-defined default
9850 // alignments for SIMD instructions on the target platforms are assumed.
9851 if (Alignment != nullptr) {
9852 ExprResult AlignResult =
9853 VerifyPositiveIntegerConstantInClause(Alignment, OMPC_aligned);
9854 if (AlignResult.isInvalid())
9856 Alignment = AlignResult.get();
9861 return OMPAlignedClause::Create(Context, StartLoc, LParenLoc, ColonLoc,
9862 EndLoc, Vars, Alignment);
9865 OMPClause *Sema::ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
9866 SourceLocation StartLoc,
9867 SourceLocation LParenLoc,
9868 SourceLocation EndLoc) {
9869 SmallVector<Expr *, 8> Vars;
9870 SmallVector<Expr *, 8> SrcExprs;
9871 SmallVector<Expr *, 8> DstExprs;
9872 SmallVector<Expr *, 8> AssignmentOps;
9873 for (auto &RefExpr : VarList) {
9874 assert(RefExpr && "NULL expr in OpenMP copyin clause.");
9875 if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
9876 // It will be analyzed later.
9877 Vars.push_back(RefExpr);
9878 SrcExprs.push_back(nullptr);
9879 DstExprs.push_back(nullptr);
9880 AssignmentOps.push_back(nullptr);
9884 SourceLocation ELoc = RefExpr->getExprLoc();
9885 // OpenMP [2.1, C/C++]
9886 // A list item is a variable name.
9887 // OpenMP [2.14.4.1, Restrictions, p.1]
9888 // A list item that appears in a copyin clause must be threadprivate.
9889 DeclRefExpr *DE = dyn_cast<DeclRefExpr>(RefExpr);
9890 if (!DE || !isa<VarDecl>(DE->getDecl())) {
9891 Diag(ELoc, diag::err_omp_expected_var_name_member_expr)
9892 << 0 << RefExpr->getSourceRange();
9896 Decl *D = DE->getDecl();
9897 VarDecl *VD = cast<VarDecl>(D);
9899 QualType Type = VD->getType();
9900 if (Type->isDependentType() || Type->isInstantiationDependentType()) {
9901 // It will be analyzed later.
9903 SrcExprs.push_back(nullptr);
9904 DstExprs.push_back(nullptr);
9905 AssignmentOps.push_back(nullptr);
9909 // OpenMP [2.14.4.1, Restrictions, C/C++, p.1]
9910 // A list item that appears in a copyin clause must be threadprivate.
9911 if (!DSAStack->isThreadPrivate(VD)) {
9912 Diag(ELoc, diag::err_omp_required_access)
9913 << getOpenMPClauseName(OMPC_copyin)
9914 << getOpenMPDirectiveName(OMPD_threadprivate);
9918 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
9919 // A variable of class type (or array thereof) that appears in a
9920 // copyin clause requires an accessible, unambiguous copy assignment
9921 // operator for the class type.
9922 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
9924 buildVarDecl(*this, DE->getLocStart(), ElemType.getUnqualifiedType(),
9925 ".copyin.src", VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9926 auto *PseudoSrcExpr = buildDeclRefExpr(
9927 *this, SrcVD, ElemType.getUnqualifiedType(), DE->getExprLoc());
9929 buildVarDecl(*this, DE->getLocStart(), ElemType, ".copyin.dst",
9930 VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9931 auto *PseudoDstExpr =
9932 buildDeclRefExpr(*this, DstVD, ElemType, DE->getExprLoc());
9933 // For arrays generate assignment operation for single element and replace
9934 // it by the original array element in CodeGen.
9935 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, DE->getExprLoc(), BO_Assign,
9936 PseudoDstExpr, PseudoSrcExpr);
9937 if (AssignmentOp.isInvalid())
9939 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), DE->getExprLoc(),
9940 /*DiscardedValue=*/true);
9941 if (AssignmentOp.isInvalid())
9944 DSAStack->addDSA(VD, DE, OMPC_copyin);
9946 SrcExprs.push_back(PseudoSrcExpr);
9947 DstExprs.push_back(PseudoDstExpr);
9948 AssignmentOps.push_back(AssignmentOp.get());
9954 return OMPCopyinClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
9955 SrcExprs, DstExprs, AssignmentOps);
9958 OMPClause *Sema::ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
9959 SourceLocation StartLoc,
9960 SourceLocation LParenLoc,
9961 SourceLocation EndLoc) {
9962 SmallVector<Expr *, 8> Vars;
9963 SmallVector<Expr *, 8> SrcExprs;
9964 SmallVector<Expr *, 8> DstExprs;
9965 SmallVector<Expr *, 8> AssignmentOps;
9966 for (auto &RefExpr : VarList) {
9967 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9968 SourceLocation ELoc;
9970 Expr *SimpleRefExpr = RefExpr;
9971 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9972 /*AllowArraySection=*/false);
9974 // It will be analyzed later.
9975 Vars.push_back(RefExpr);
9976 SrcExprs.push_back(nullptr);
9977 DstExprs.push_back(nullptr);
9978 AssignmentOps.push_back(nullptr);
9980 ValueDecl *D = Res.first;
9984 QualType Type = D->getType();
9985 auto *VD = dyn_cast<VarDecl>(D);
9987 // OpenMP [2.14.4.2, Restrictions, p.2]
9988 // A list item that appears in a copyprivate clause may not appear in a
9989 // private or firstprivate clause on the single construct.
9990 if (!VD || !DSAStack->isThreadPrivate(VD)) {
9991 auto DVar = DSAStack->getTopDSA(D, false);
9992 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_copyprivate &&
9994 Diag(ELoc, diag::err_omp_wrong_dsa)
9995 << getOpenMPClauseName(DVar.CKind)
9996 << getOpenMPClauseName(OMPC_copyprivate);
9997 ReportOriginalDSA(*this, DSAStack, D, DVar);
10001 // OpenMP [2.11.4.2, Restrictions, p.1]
10002 // All list items that appear in a copyprivate clause must be either
10003 // threadprivate or private in the enclosing context.
10004 if (DVar.CKind == OMPC_unknown) {
10005 DVar = DSAStack->getImplicitDSA(D, false);
10006 if (DVar.CKind == OMPC_shared) {
10007 Diag(ELoc, diag::err_omp_required_access)
10008 << getOpenMPClauseName(OMPC_copyprivate)
10009 << "threadprivate or private in the enclosing context";
10010 ReportOriginalDSA(*this, DSAStack, D, DVar);
10016 // Variably modified types are not supported.
10017 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType()) {
10018 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
10019 << getOpenMPClauseName(OMPC_copyprivate) << Type
10020 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
10023 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
10024 Diag(D->getLocation(),
10025 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
10030 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
10031 // A variable of class type (or array thereof) that appears in a
10032 // copyin clause requires an accessible, unambiguous copy assignment
10033 // operator for the class type.
10034 Type = Context.getBaseElementType(Type.getNonReferenceType())
10035 .getUnqualifiedType();
10037 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.src",
10038 D->hasAttrs() ? &D->getAttrs() : nullptr);
10039 auto *PseudoSrcExpr = buildDeclRefExpr(*this, SrcVD, Type, ELoc);
10041 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.dst",
10042 D->hasAttrs() ? &D->getAttrs() : nullptr);
10043 auto *PseudoDstExpr =
10044 buildDeclRefExpr(*this, DstVD, Type, ELoc);
10045 auto AssignmentOp = BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
10046 PseudoDstExpr, PseudoSrcExpr);
10047 if (AssignmentOp.isInvalid())
10049 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
10050 /*DiscardedValue=*/true);
10051 if (AssignmentOp.isInvalid())
10054 // No need to mark vars as copyprivate, they are already threadprivate or
10055 // implicitly private.
10056 assert(VD || IsOpenMPCapturedDecl(D));
10058 VD ? RefExpr->IgnoreParens()
10059 : buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false));
10060 SrcExprs.push_back(PseudoSrcExpr);
10061 DstExprs.push_back(PseudoDstExpr);
10062 AssignmentOps.push_back(AssignmentOp.get());
10068 return OMPCopyprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10069 Vars, SrcExprs, DstExprs, AssignmentOps);
10072 OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
10073 SourceLocation StartLoc,
10074 SourceLocation LParenLoc,
10075 SourceLocation EndLoc) {
10076 if (VarList.empty())
10079 return OMPFlushClause::Create(Context, StartLoc, LParenLoc, EndLoc, VarList);
10083 Sema::ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind,
10084 SourceLocation DepLoc, SourceLocation ColonLoc,
10085 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
10086 SourceLocation LParenLoc, SourceLocation EndLoc) {
10087 if (DSAStack->getCurrentDirective() == OMPD_ordered &&
10088 DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink) {
10089 Diag(DepLoc, diag::err_omp_unexpected_clause_value)
10090 << "'source' or 'sink'" << getOpenMPClauseName(OMPC_depend);
10093 if (DSAStack->getCurrentDirective() != OMPD_ordered &&
10094 (DepKind == OMPC_DEPEND_unknown || DepKind == OMPC_DEPEND_source ||
10095 DepKind == OMPC_DEPEND_sink)) {
10096 unsigned Except[] = {OMPC_DEPEND_source, OMPC_DEPEND_sink};
10097 Diag(DepLoc, diag::err_omp_unexpected_clause_value)
10098 << getListOfPossibleValues(OMPC_depend, /*First=*/0,
10099 /*Last=*/OMPC_DEPEND_unknown, Except)
10100 << getOpenMPClauseName(OMPC_depend);
10103 SmallVector<Expr *, 8> Vars;
10104 DSAStackTy::OperatorOffsetTy OpsOffs;
10105 llvm::APSInt DepCounter(/*BitWidth=*/32);
10106 llvm::APSInt TotalDepCount(/*BitWidth=*/32);
10107 if (DepKind == OMPC_DEPEND_sink) {
10108 if (auto *OrderedCountExpr = DSAStack->getParentOrderedRegionParam()) {
10109 TotalDepCount = OrderedCountExpr->EvaluateKnownConstInt(Context);
10110 TotalDepCount.setIsUnsigned(/*Val=*/true);
10113 if ((DepKind != OMPC_DEPEND_sink && DepKind != OMPC_DEPEND_source) ||
10114 DSAStack->getParentOrderedRegionParam()) {
10115 for (auto &RefExpr : VarList) {
10116 assert(RefExpr && "NULL expr in OpenMP shared clause.");
10117 if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
10118 // It will be analyzed later.
10119 Vars.push_back(RefExpr);
10123 SourceLocation ELoc = RefExpr->getExprLoc();
10124 auto *SimpleExpr = RefExpr->IgnoreParenCasts();
10125 if (DepKind == OMPC_DEPEND_sink) {
10126 if (DepCounter >= TotalDepCount) {
10127 Diag(ELoc, diag::err_omp_depend_sink_unexpected_expr);
10131 // OpenMP [2.13.9, Summary]
10132 // depend(dependence-type : vec), where dependence-type is:
10133 // 'sink' and where vec is the iteration vector, which has the form:
10134 // x1 [+- d1], x2 [+- d2 ], . . . , xn [+- dn]
10135 // where n is the value specified by the ordered clause in the loop
10136 // directive, xi denotes the loop iteration variable of the i-th nested
10137 // loop associated with the loop directive, and di is a constant
10138 // non-negative integer.
10139 if (CurContext->isDependentContext()) {
10140 // It will be analyzed later.
10141 Vars.push_back(RefExpr);
10144 SimpleExpr = SimpleExpr->IgnoreImplicit();
10145 OverloadedOperatorKind OOK = OO_None;
10146 SourceLocation OOLoc;
10147 Expr *LHS = SimpleExpr;
10148 Expr *RHS = nullptr;
10149 if (auto *BO = dyn_cast<BinaryOperator>(SimpleExpr)) {
10150 OOK = BinaryOperator::getOverloadedOperator(BO->getOpcode());
10151 OOLoc = BO->getOperatorLoc();
10152 LHS = BO->getLHS()->IgnoreParenImpCasts();
10153 RHS = BO->getRHS()->IgnoreParenImpCasts();
10154 } else if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(SimpleExpr)) {
10155 OOK = OCE->getOperator();
10156 OOLoc = OCE->getOperatorLoc();
10157 LHS = OCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
10158 RHS = OCE->getArg(/*Arg=*/1)->IgnoreParenImpCasts();
10159 } else if (auto *MCE = dyn_cast<CXXMemberCallExpr>(SimpleExpr)) {
10160 OOK = MCE->getMethodDecl()
10163 .getCXXOverloadedOperator();
10164 OOLoc = MCE->getCallee()->getExprLoc();
10165 LHS = MCE->getImplicitObjectArgument()->IgnoreParenImpCasts();
10166 RHS = MCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
10168 SourceLocation ELoc;
10169 SourceRange ERange;
10170 auto Res = getPrivateItem(*this, LHS, ELoc, ERange,
10171 /*AllowArraySection=*/false);
10173 // It will be analyzed later.
10174 Vars.push_back(RefExpr);
10176 ValueDecl *D = Res.first;
10180 if (OOK != OO_Plus && OOK != OO_Minus && (RHS || OOK != OO_None)) {
10181 Diag(OOLoc, diag::err_omp_depend_sink_expected_plus_minus);
10185 ExprResult RHSRes = VerifyPositiveIntegerConstantInClause(
10186 RHS, OMPC_depend, /*StrictlyPositive=*/false);
10187 if (RHSRes.isInvalid())
10190 if (!CurContext->isDependentContext() &&
10191 DSAStack->getParentOrderedRegionParam() &&
10192 DepCounter != DSAStack->isParentLoopControlVariable(D).first) {
10193 Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration)
10194 << DSAStack->getParentLoopControlVariable(
10195 DepCounter.getZExtValue());
10198 OpsOffs.push_back({RHS, OOK});
10200 // OpenMP [2.11.1.1, Restrictions, p.3]
10201 // A variable that is part of another variable (such as a field of a
10202 // structure) but is not an array element or an array section cannot
10203 // appear in a depend clause.
10204 auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr);
10205 auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr);
10206 auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr);
10207 if (!RefExpr->IgnoreParenImpCasts()->isLValue() ||
10208 (!ASE && !DE && !OASE) || (DE && !isa<VarDecl>(DE->getDecl())) ||
10212 .getNonReferenceType()
10213 ->isPointerType() &&
10214 !ASE->getBase()->getType().getNonReferenceType()->isArrayType())) {
10215 Diag(ELoc, diag::err_omp_expected_var_name_member_expr_or_array_item)
10216 << 0 << RefExpr->getSourceRange();
10220 Vars.push_back(RefExpr->IgnoreParenImpCasts());
10223 if (!CurContext->isDependentContext() && DepKind == OMPC_DEPEND_sink &&
10224 TotalDepCount > VarList.size() &&
10225 DSAStack->getParentOrderedRegionParam()) {
10226 Diag(EndLoc, diag::err_omp_depend_sink_expected_loop_iteration)
10227 << DSAStack->getParentLoopControlVariable(VarList.size() + 1);
10229 if (DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink &&
10233 auto *C = OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10234 DepKind, DepLoc, ColonLoc, Vars);
10235 if (DepKind == OMPC_DEPEND_sink || DepKind == OMPC_DEPEND_source)
10236 DSAStack->addDoacrossDependClause(C, OpsOffs);
10240 OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
10241 SourceLocation LParenLoc,
10242 SourceLocation EndLoc) {
10243 Expr *ValExpr = Device;
10245 // OpenMP [2.9.1, Restrictions]
10246 // The device expression must evaluate to a non-negative integer value.
10247 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_device,
10248 /*StrictlyPositive=*/false))
10251 return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10254 static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc,
10255 DSAStackTy *Stack, CXXRecordDecl *RD) {
10256 if (!RD || RD->isInvalidDecl())
10259 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
10260 if (auto *CTD = CTSD->getSpecializedTemplate())
10261 RD = CTD->getTemplatedDecl();
10262 auto QTy = SemaRef.Context.getRecordType(RD);
10263 if (RD->isDynamicClass()) {
10264 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10265 SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target);
10269 bool IsCorrect = true;
10270 for (auto *I : DC->decls()) {
10272 if (auto *MD = dyn_cast<CXXMethodDecl>(I)) {
10273 if (MD->isStatic()) {
10274 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10275 SemaRef.Diag(MD->getLocation(),
10276 diag::note_omp_static_member_in_target);
10279 } else if (auto *VD = dyn_cast<VarDecl>(I)) {
10280 if (VD->isStaticDataMember()) {
10281 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10282 SemaRef.Diag(VD->getLocation(),
10283 diag::note_omp_static_member_in_target);
10290 for (auto &I : RD->bases()) {
10291 if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack,
10292 I.getType()->getAsCXXRecordDecl()))
10298 static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
10299 DSAStackTy *Stack, QualType QTy) {
10301 if (QTy->isIncompleteType(&ND)) {
10302 SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
10304 } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) {
10305 if (!RD->isInvalidDecl() &&
10306 !IsCXXRecordForMappable(SemaRef, SL, Stack, RD))
10312 /// \brief Return true if it can be proven that the provided array expression
10313 /// (array section or array subscript) does NOT specify the whole size of the
10314 /// array whose base type is \a BaseQTy.
10315 static bool CheckArrayExpressionDoesNotReferToWholeSize(Sema &SemaRef,
10317 QualType BaseQTy) {
10318 auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
10320 // If this is an array subscript, it refers to the whole size if the size of
10321 // the dimension is constant and equals 1. Also, an array section assumes the
10322 // format of an array subscript if no colon is used.
10323 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid())) {
10324 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
10325 return ATy->getSize().getSExtValue() != 1;
10326 // Size can't be evaluated statically.
10330 assert(OASE && "Expecting array section if not an array subscript.");
10331 auto *LowerBound = OASE->getLowerBound();
10332 auto *Length = OASE->getLength();
10334 // If there is a lower bound that does not evaluates to zero, we are not
10335 // convering the whole dimension.
10337 llvm::APSInt ConstLowerBound;
10338 if (!LowerBound->EvaluateAsInt(ConstLowerBound, SemaRef.getASTContext()))
10339 return false; // Can't get the integer value as a constant.
10340 if (ConstLowerBound.getSExtValue())
10344 // If we don't have a length we covering the whole dimension.
10348 // If the base is a pointer, we don't have a way to get the size of the
10350 if (BaseQTy->isPointerType())
10353 // We can only check if the length is the same as the size of the dimension
10354 // if we have a constant array.
10355 auto *CATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr());
10359 llvm::APSInt ConstLength;
10360 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
10361 return false; // Can't get the integer value as a constant.
10363 return CATy->getSize().getSExtValue() != ConstLength.getSExtValue();
10366 // Return true if it can be proven that the provided array expression (array
10367 // section or array subscript) does NOT specify a single element of the array
10368 // whose base type is \a BaseQTy.
10369 static bool CheckArrayExpressionDoesNotReferToUnitySize(Sema &SemaRef,
10371 QualType BaseQTy) {
10372 auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
10374 // An array subscript always refer to a single element. Also, an array section
10375 // assumes the format of an array subscript if no colon is used.
10376 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid()))
10379 assert(OASE && "Expecting array section if not an array subscript.");
10380 auto *Length = OASE->getLength();
10382 // If we don't have a length we have to check if the array has unitary size
10383 // for this dimension. Also, we should always expect a length if the base type
10386 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
10387 return ATy->getSize().getSExtValue() != 1;
10388 // We cannot assume anything.
10392 // Check if the length evaluates to 1.
10393 llvm::APSInt ConstLength;
10394 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
10395 return false; // Can't get the integer value as a constant.
10397 return ConstLength.getSExtValue() != 1;
10400 // Return the expression of the base of the mappable expression or null if it
10401 // cannot be determined and do all the necessary checks to see if the expression
10402 // is valid as a standalone mappable expression. In the process, record all the
10403 // components of the expression.
10404 static Expr *CheckMapClauseExpressionBase(
10405 Sema &SemaRef, Expr *E,
10406 OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents,
10407 OpenMPClauseKind CKind) {
10408 SourceLocation ELoc = E->getExprLoc();
10409 SourceRange ERange = E->getSourceRange();
10411 // The base of elements of list in a map clause have to be either:
10412 // - a reference to variable or field.
10413 // - a member expression.
10414 // - an array expression.
10416 // E.g. if we have the expression 'r.S.Arr[:12]', we want to retrieve the
10417 // reference to 'r'.
10424 // #pragma omp target map (S.Arr[:12]);
10428 // We want to retrieve the member expression 'this->S';
10430 Expr *RelevantExpr = nullptr;
10432 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.2]
10433 // If a list item is an array section, it must specify contiguous storage.
10435 // For this restriction it is sufficient that we make sure only references
10436 // to variables or fields and array expressions, and that no array sections
10437 // exist except in the rightmost expression (unless they cover the whole
10438 // dimension of the array). E.g. these would be invalid:
10440 // r.ArrS[3:5].Arr[6:7]
10444 // but these would be valid:
10445 // r.ArrS[3].Arr[6:7]
10449 bool AllowUnitySizeArraySection = true;
10450 bool AllowWholeSizeArraySection = true;
10452 while (!RelevantExpr) {
10453 E = E->IgnoreParenImpCasts();
10455 if (auto *CurE = dyn_cast<DeclRefExpr>(E)) {
10456 if (!isa<VarDecl>(CurE->getDecl()))
10459 RelevantExpr = CurE;
10461 // If we got a reference to a declaration, we should not expect any array
10462 // section before that.
10463 AllowUnitySizeArraySection = false;
10464 AllowWholeSizeArraySection = false;
10466 // Record the component.
10467 CurComponents.push_back(OMPClauseMappableExprCommon::MappableComponent(
10468 CurE, CurE->getDecl()));
10472 if (auto *CurE = dyn_cast<MemberExpr>(E)) {
10473 auto *BaseE = CurE->getBase()->IgnoreParenImpCasts();
10475 if (isa<CXXThisExpr>(BaseE))
10476 // We found a base expression: this->Val.
10477 RelevantExpr = CurE;
10481 if (!isa<FieldDecl>(CurE->getMemberDecl())) {
10482 SemaRef.Diag(ELoc, diag::err_omp_expected_access_to_data_field)
10483 << CurE->getSourceRange();
10487 auto *FD = cast<FieldDecl>(CurE->getMemberDecl());
10489 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3]
10490 // A bit-field cannot appear in a map clause.
10492 if (FD->isBitField()) {
10493 SemaRef.Diag(ELoc, diag::err_omp_bit_fields_forbidden_in_clause)
10494 << CurE->getSourceRange() << getOpenMPClauseName(CKind);
10498 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10499 // If the type of a list item is a reference to a type T then the type
10500 // will be considered to be T for all purposes of this clause.
10501 QualType CurType = BaseE->getType().getNonReferenceType();
10503 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.2]
10504 // A list item cannot be a variable that is a member of a structure with
10507 if (auto *RT = CurType->getAs<RecordType>())
10508 if (RT->isUnionType()) {
10509 SemaRef.Diag(ELoc, diag::err_omp_union_type_not_allowed)
10510 << CurE->getSourceRange();
10514 // If we got a member expression, we should not expect any array section
10517 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7]
10518 // If a list item is an element of a structure, only the rightmost symbol
10519 // of the variable reference can be an array section.
10521 AllowUnitySizeArraySection = false;
10522 AllowWholeSizeArraySection = false;
10524 // Record the component.
10525 CurComponents.push_back(
10526 OMPClauseMappableExprCommon::MappableComponent(CurE, FD));
10530 if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) {
10531 E = CurE->getBase()->IgnoreParenImpCasts();
10533 if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) {
10534 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
10535 << 0 << CurE->getSourceRange();
10539 // If we got an array subscript that express the whole dimension we
10540 // can have any array expressions before. If it only expressing part of
10541 // the dimension, we can only have unitary-size array expressions.
10542 if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE,
10544 AllowWholeSizeArraySection = false;
10546 // Record the component - we don't have any declaration associated.
10547 CurComponents.push_back(
10548 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
10552 if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) {
10553 E = CurE->getBase()->IgnoreParenImpCasts();
10556 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
10558 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10559 // If the type of a list item is a reference to a type T then the type
10560 // will be considered to be T for all purposes of this clause.
10561 if (CurType->isReferenceType())
10562 CurType = CurType->getPointeeType();
10564 bool IsPointer = CurType->isAnyPointerType();
10566 if (!IsPointer && !CurType->isArrayType()) {
10567 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
10568 << 0 << CurE->getSourceRange();
10573 CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, CurType);
10575 CheckArrayExpressionDoesNotReferToUnitySize(SemaRef, CurE, CurType);
10577 if (AllowWholeSizeArraySection && AllowUnitySizeArraySection) {
10578 // Any array section is currently allowed.
10580 // If this array section refers to the whole dimension we can still
10581 // accept other array sections before this one, except if the base is a
10582 // pointer. Otherwise, only unitary sections are accepted.
10583 if (NotWhole || IsPointer)
10584 AllowWholeSizeArraySection = false;
10585 } else if ((AllowUnitySizeArraySection && NotUnity) ||
10586 (AllowWholeSizeArraySection && NotWhole)) {
10587 // A unity or whole array section is not allowed and that is not
10588 // compatible with the properties of the current array section.
10590 ELoc, diag::err_array_section_does_not_specify_contiguous_storage)
10591 << CurE->getSourceRange();
10595 // Record the component - we don't have any declaration associated.
10596 CurComponents.push_back(
10597 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
10601 // If nothing else worked, this is not a valid map clause expression.
10603 diag::err_omp_expected_named_var_member_or_array_expression)
10608 return RelevantExpr;
10611 // Return true if expression E associated with value VD has conflicts with other
10612 // map information.
10613 static bool CheckMapConflicts(
10614 Sema &SemaRef, DSAStackTy *DSAS, ValueDecl *VD, Expr *E,
10615 bool CurrentRegionOnly,
10616 OMPClauseMappableExprCommon::MappableExprComponentListRef CurComponents,
10617 OpenMPClauseKind CKind) {
10619 SourceLocation ELoc = E->getExprLoc();
10620 SourceRange ERange = E->getSourceRange();
10622 // In order to easily check the conflicts we need to match each component of
10623 // the expression under test with the components of the expressions that are
10624 // already in the stack.
10626 assert(!CurComponents.empty() && "Map clause expression with no components!");
10627 assert(CurComponents.back().getAssociatedDeclaration() == VD &&
10628 "Map clause expression with unexpected base!");
10630 // Variables to help detecting enclosing problems in data environment nests.
10631 bool IsEnclosedByDataEnvironmentExpr = false;
10632 const Expr *EnclosingExpr = nullptr;
10634 bool FoundError = DSAS->checkMappableExprComponentListsForDecl(
10635 VD, CurrentRegionOnly,
10636 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
10637 StackComponents) -> bool {
10639 assert(!StackComponents.empty() &&
10640 "Map clause expression with no components!");
10641 assert(StackComponents.back().getAssociatedDeclaration() == VD &&
10642 "Map clause expression with unexpected base!");
10644 // The whole expression in the stack.
10645 auto *RE = StackComponents.front().getAssociatedExpression();
10647 // Expressions must start from the same base. Here we detect at which
10648 // point both expressions diverge from each other and see if we can
10649 // detect if the memory referred to both expressions is contiguous and
10651 auto CI = CurComponents.rbegin();
10652 auto CE = CurComponents.rend();
10653 auto SI = StackComponents.rbegin();
10654 auto SE = StackComponents.rend();
10655 for (; CI != CE && SI != SE; ++CI, ++SI) {
10657 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.3]
10658 // At most one list item can be an array item derived from a given
10659 // variable in map clauses of the same construct.
10660 if (CurrentRegionOnly &&
10661 (isa<ArraySubscriptExpr>(CI->getAssociatedExpression()) ||
10662 isa<OMPArraySectionExpr>(CI->getAssociatedExpression())) &&
10663 (isa<ArraySubscriptExpr>(SI->getAssociatedExpression()) ||
10664 isa<OMPArraySectionExpr>(SI->getAssociatedExpression()))) {
10665 SemaRef.Diag(CI->getAssociatedExpression()->getExprLoc(),
10666 diag::err_omp_multiple_array_items_in_map_clause)
10667 << CI->getAssociatedExpression()->getSourceRange();
10668 SemaRef.Diag(SI->getAssociatedExpression()->getExprLoc(),
10669 diag::note_used_here)
10670 << SI->getAssociatedExpression()->getSourceRange();
10674 // Do both expressions have the same kind?
10675 if (CI->getAssociatedExpression()->getStmtClass() !=
10676 SI->getAssociatedExpression()->getStmtClass())
10679 // Are we dealing with different variables/fields?
10680 if (CI->getAssociatedDeclaration() != SI->getAssociatedDeclaration())
10683 // Check if the extra components of the expressions in the enclosing
10684 // data environment are redundant for the current base declaration.
10685 // If they are, the maps completely overlap, which is legal.
10686 for (; SI != SE; ++SI) {
10689 dyn_cast<ArraySubscriptExpr>(SI->getAssociatedExpression())) {
10690 Type = ASE->getBase()->IgnoreParenImpCasts()->getType();
10691 } else if (auto *OASE =
10692 dyn_cast<OMPArraySectionExpr>(SI->getAssociatedExpression())) {
10693 auto *E = OASE->getBase()->IgnoreParenImpCasts();
10695 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
10697 if (Type.isNull() || Type->isAnyPointerType() ||
10698 CheckArrayExpressionDoesNotReferToWholeSize(
10699 SemaRef, SI->getAssociatedExpression(), Type))
10703 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10704 // List items of map clauses in the same construct must not share
10705 // original storage.
10707 // If the expressions are exactly the same or one is a subset of the
10708 // other, it means they are sharing storage.
10709 if (CI == CE && SI == SE) {
10710 if (CurrentRegionOnly) {
10711 if (CKind == OMPC_map)
10712 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10714 assert(CKind == OMPC_to || CKind == OMPC_from);
10715 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10718 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10719 << RE->getSourceRange();
10722 // If we find the same expression in the enclosing data environment,
10724 IsEnclosedByDataEnvironmentExpr = true;
10729 QualType DerivedType =
10730 std::prev(CI)->getAssociatedDeclaration()->getType();
10731 SourceLocation DerivedLoc =
10732 std::prev(CI)->getAssociatedExpression()->getExprLoc();
10734 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10735 // If the type of a list item is a reference to a type T then the type
10736 // will be considered to be T for all purposes of this clause.
10737 DerivedType = DerivedType.getNonReferenceType();
10739 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.1]
10740 // A variable for which the type is pointer and an array section
10741 // derived from that variable must not appear as list items of map
10742 // clauses of the same construct.
10744 // Also, cover one of the cases in:
10745 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10746 // If any part of the original storage of a list item has corresponding
10747 // storage in the device data environment, all of the original storage
10748 // must have corresponding storage in the device data environment.
10750 if (DerivedType->isAnyPointerType()) {
10751 if (CI == CE || SI == SE) {
10754 diag::err_omp_pointer_mapped_along_with_derived_section)
10757 assert(CI != CE && SI != SE);
10758 SemaRef.Diag(DerivedLoc, diag::err_omp_same_pointer_derreferenced)
10761 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10762 << RE->getSourceRange();
10766 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10767 // List items of map clauses in the same construct must not share
10768 // original storage.
10770 // An expression is a subset of the other.
10771 if (CurrentRegionOnly && (CI == CE || SI == SE)) {
10772 if (CKind == OMPC_map)
10773 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10775 assert(CKind == OMPC_to || CKind == OMPC_from);
10776 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10779 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10780 << RE->getSourceRange();
10784 // The current expression uses the same base as other expression in the
10785 // data environment but does not contain it completely.
10786 if (!CurrentRegionOnly && SI != SE)
10787 EnclosingExpr = RE;
10789 // The current expression is a subset of the expression in the data
10791 IsEnclosedByDataEnvironmentExpr |=
10792 (!CurrentRegionOnly && CI != CE && SI == SE);
10797 if (CurrentRegionOnly)
10800 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10801 // If any part of the original storage of a list item has corresponding
10802 // storage in the device data environment, all of the original storage must
10803 // have corresponding storage in the device data environment.
10804 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.6]
10805 // If a list item is an element of a structure, and a different element of
10806 // the structure has a corresponding list item in the device data environment
10807 // prior to a task encountering the construct associated with the map clause,
10808 // then the list item must also have a corresponding list item in the device
10809 // data environment prior to the task encountering the construct.
10811 if (EnclosingExpr && !IsEnclosedByDataEnvironmentExpr) {
10813 diag::err_omp_original_storage_is_shared_and_does_not_contain)
10815 SemaRef.Diag(EnclosingExpr->getExprLoc(), diag::note_used_here)
10816 << EnclosingExpr->getSourceRange();
10824 // Utility struct that gathers all the related lists associated with a mappable
10826 struct MappableVarListInfo final {
10827 // The list of expressions.
10828 ArrayRef<Expr *> VarList;
10829 // The list of processed expressions.
10830 SmallVector<Expr *, 16> ProcessedVarList;
10831 // The mappble components for each expression.
10832 OMPClauseMappableExprCommon::MappableExprComponentLists VarComponents;
10833 // The base declaration of the variable.
10834 SmallVector<ValueDecl *, 16> VarBaseDeclarations;
10836 MappableVarListInfo(ArrayRef<Expr *> VarList) : VarList(VarList) {
10837 // We have a list of components and base declarations for each entry in the
10839 VarComponents.reserve(VarList.size());
10840 VarBaseDeclarations.reserve(VarList.size());
10845 // Check the validity of the provided variable list for the provided clause kind
10846 // \a CKind. In the check process the valid expressions, and mappable expression
10847 // components and variables are extracted and used to fill \a Vars,
10848 // \a ClauseComponents, and \a ClauseBaseDeclarations. \a MapType and
10849 // \a IsMapTypeImplicit are expected to be valid if the clause kind is 'map'.
10851 checkMappableExpressionList(Sema &SemaRef, DSAStackTy *DSAS,
10852 OpenMPClauseKind CKind, MappableVarListInfo &MVLI,
10853 SourceLocation StartLoc,
10854 OpenMPMapClauseKind MapType = OMPC_MAP_unknown,
10855 bool IsMapTypeImplicit = false) {
10856 // We only expect mappable expressions in 'to', 'from', and 'map' clauses.
10857 assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from) &&
10858 "Unexpected clause kind with mappable expressions!");
10860 // Keep track of the mappable components and base declarations in this clause.
10861 // Each entry in the list is going to have a list of components associated. We
10862 // record each set of the components so that we can build the clause later on.
10863 // In the end we should have the same amount of declarations and component
10866 for (auto &RE : MVLI.VarList) {
10867 assert(RE && "Null expr in omp to/from/map clause");
10868 SourceLocation ELoc = RE->getExprLoc();
10870 auto *VE = RE->IgnoreParenLValueCasts();
10872 if (VE->isValueDependent() || VE->isTypeDependent() ||
10873 VE->isInstantiationDependent() ||
10874 VE->containsUnexpandedParameterPack()) {
10875 // We can only analyze this information once the missing information is
10877 MVLI.ProcessedVarList.push_back(RE);
10881 auto *SimpleExpr = RE->IgnoreParenCasts();
10883 if (!RE->IgnoreParenImpCasts()->isLValue()) {
10885 diag::err_omp_expected_named_var_member_or_array_expression)
10886 << RE->getSourceRange();
10890 OMPClauseMappableExprCommon::MappableExprComponentList CurComponents;
10891 ValueDecl *CurDeclaration = nullptr;
10893 // Obtain the array or member expression bases if required. Also, fill the
10894 // components array with all the components identified in the process.
10896 CheckMapClauseExpressionBase(SemaRef, SimpleExpr, CurComponents, CKind);
10900 assert(!CurComponents.empty() &&
10901 "Invalid mappable expression information.");
10903 // For the following checks, we rely on the base declaration which is
10904 // expected to be associated with the last component. The declaration is
10905 // expected to be a variable or a field (if 'this' is being mapped).
10906 CurDeclaration = CurComponents.back().getAssociatedDeclaration();
10907 assert(CurDeclaration && "Null decl on map clause.");
10909 CurDeclaration->isCanonicalDecl() &&
10910 "Expecting components to have associated only canonical declarations.");
10912 auto *VD = dyn_cast<VarDecl>(CurDeclaration);
10913 auto *FD = dyn_cast<FieldDecl>(CurDeclaration);
10915 assert((VD || FD) && "Only variables or fields are expected here!");
10918 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.10]
10919 // threadprivate variables cannot appear in a map clause.
10920 // OpenMP 4.5 [2.10.5, target update Construct]
10921 // threadprivate variables cannot appear in a from clause.
10922 if (VD && DSAS->isThreadPrivate(VD)) {
10923 auto DVar = DSAS->getTopDSA(VD, false);
10924 SemaRef.Diag(ELoc, diag::err_omp_threadprivate_in_clause)
10925 << getOpenMPClauseName(CKind);
10926 ReportOriginalDSA(SemaRef, DSAS, VD, DVar);
10930 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10931 // A list item cannot appear in both a map clause and a data-sharing
10932 // attribute clause on the same construct.
10934 // Check conflicts with other map clause expressions. We check the conflicts
10935 // with the current construct separately from the enclosing data
10936 // environment, because the restrictions are different. We only have to
10937 // check conflicts across regions for the map clauses.
10938 if (CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10939 /*CurrentRegionOnly=*/true, CurComponents, CKind))
10941 if (CKind == OMPC_map &&
10942 CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10943 /*CurrentRegionOnly=*/false, CurComponents, CKind))
10946 // OpenMP 4.5 [2.10.5, target update Construct]
10947 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10948 // If the type of a list item is a reference to a type T then the type will
10949 // be considered to be T for all purposes of this clause.
10950 QualType Type = CurDeclaration->getType().getNonReferenceType();
10952 // OpenMP 4.5 [2.10.5, target update Construct, Restrictions, p.4]
10953 // A list item in a to or from clause must have a mappable type.
10954 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10955 // A list item must have a mappable type.
10956 if (!CheckTypeMappable(VE->getExprLoc(), VE->getSourceRange(), SemaRef,
10960 if (CKind == OMPC_map) {
10961 // target enter data
10962 // OpenMP [2.10.2, Restrictions, p. 99]
10963 // A map-type must be specified in all map clauses and must be either
10965 OpenMPDirectiveKind DKind = DSAS->getCurrentDirective();
10966 if (DKind == OMPD_target_enter_data &&
10967 !(MapType == OMPC_MAP_to || MapType == OMPC_MAP_alloc)) {
10968 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10969 << (IsMapTypeImplicit ? 1 : 0)
10970 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10971 << getOpenMPDirectiveName(DKind);
10975 // target exit_data
10976 // OpenMP [2.10.3, Restrictions, p. 102]
10977 // A map-type must be specified in all map clauses and must be either
10978 // from, release, or delete.
10979 if (DKind == OMPD_target_exit_data &&
10980 !(MapType == OMPC_MAP_from || MapType == OMPC_MAP_release ||
10981 MapType == OMPC_MAP_delete)) {
10982 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10983 << (IsMapTypeImplicit ? 1 : 0)
10984 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10985 << getOpenMPDirectiveName(DKind);
10989 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
10990 // A list item cannot appear in both a map clause and a data-sharing
10991 // attribute clause on the same construct
10992 if (DKind == OMPD_target && VD) {
10993 auto DVar = DSAS->getTopDSA(VD, false);
10994 if (isOpenMPPrivate(DVar.CKind)) {
10995 SemaRef.Diag(ELoc, diag::err_omp_variable_in_map_and_dsa)
10996 << getOpenMPClauseName(DVar.CKind)
10997 << getOpenMPDirectiveName(DSAS->getCurrentDirective());
10998 ReportOriginalDSA(SemaRef, DSAS, CurDeclaration, DVar);
11004 // Save the current expression.
11005 MVLI.ProcessedVarList.push_back(RE);
11007 // Store the components in the stack so that they can be used to check
11008 // against other clauses later on.
11009 DSAS->addMappableExpressionComponents(CurDeclaration, CurComponents);
11011 // Save the components and declaration to create the clause. For purposes of
11012 // the clause creation, any component list that has has base 'this' uses
11013 // null as base declaration.
11014 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
11015 MVLI.VarComponents.back().append(CurComponents.begin(),
11016 CurComponents.end());
11017 MVLI.VarBaseDeclarations.push_back(isa<MemberExpr>(BE) ? nullptr
11023 Sema::ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,
11024 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
11025 SourceLocation MapLoc, SourceLocation ColonLoc,
11026 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11027 SourceLocation LParenLoc, SourceLocation EndLoc) {
11028 MappableVarListInfo MVLI(VarList);
11029 checkMappableExpressionList(*this, DSAStack, OMPC_map, MVLI, StartLoc,
11030 MapType, IsMapTypeImplicit);
11032 // We need to produce a map clause even if we don't have variables so that
11033 // other diagnostics related with non-existing map clauses are accurate.
11034 return OMPMapClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11035 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11036 MVLI.VarComponents, MapTypeModifier, MapType,
11037 IsMapTypeImplicit, MapLoc);
11040 QualType Sema::ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
11041 TypeResult ParsedType) {
11042 assert(ParsedType.isUsable());
11044 QualType ReductionType = GetTypeFromParser(ParsedType.get());
11045 if (ReductionType.isNull())
11048 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions, C\C++
11049 // A type name in a declare reduction directive cannot be a function type, an
11050 // array type, a reference type, or a type qualified with const, volatile or
11052 if (ReductionType.hasQualifiers()) {
11053 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 0;
11057 if (ReductionType->isFunctionType()) {
11058 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 1;
11061 if (ReductionType->isReferenceType()) {
11062 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 2;
11065 if (ReductionType->isArrayType()) {
11066 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 3;
11069 return ReductionType;
11072 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveStart(
11073 Scope *S, DeclContext *DC, DeclarationName Name,
11074 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
11075 AccessSpecifier AS, Decl *PrevDeclInScope) {
11076 SmallVector<Decl *, 8> Decls;
11077 Decls.reserve(ReductionTypes.size());
11079 LookupResult Lookup(*this, Name, SourceLocation(), LookupOMPReductionName,
11081 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
11082 // A reduction-identifier may not be re-declared in the current scope for the
11083 // same type or for a type that is compatible according to the base language
11085 llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
11086 OMPDeclareReductionDecl *PrevDRD = nullptr;
11087 bool InCompoundScope = true;
11088 if (S != nullptr) {
11089 // Find previous declaration with the same name not referenced in other
11091 FunctionScopeInfo *ParentFn = getEnclosingFunction();
11093 (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty();
11094 LookupName(Lookup, S);
11095 FilterLookupForScope(Lookup, DC, S, /*ConsiderLinkage=*/false,
11096 /*AllowInlineNamespace=*/false);
11097 llvm::DenseMap<OMPDeclareReductionDecl *, bool> UsedAsPrevious;
11098 auto Filter = Lookup.makeFilter();
11099 while (Filter.hasNext()) {
11100 auto *PrevDecl = cast<OMPDeclareReductionDecl>(Filter.next());
11101 if (InCompoundScope) {
11102 auto I = UsedAsPrevious.find(PrevDecl);
11103 if (I == UsedAsPrevious.end())
11104 UsedAsPrevious[PrevDecl] = false;
11105 if (auto *D = PrevDecl->getPrevDeclInScope())
11106 UsedAsPrevious[D] = true;
11108 PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] =
11109 PrevDecl->getLocation();
11112 if (InCompoundScope) {
11113 for (auto &PrevData : UsedAsPrevious) {
11114 if (!PrevData.second) {
11115 PrevDRD = PrevData.first;
11120 } else if (PrevDeclInScope != nullptr) {
11121 auto *PrevDRDInScope = PrevDRD =
11122 cast<OMPDeclareReductionDecl>(PrevDeclInScope);
11124 PreviousRedeclTypes[PrevDRDInScope->getType().getCanonicalType()] =
11125 PrevDRDInScope->getLocation();
11126 PrevDRDInScope = PrevDRDInScope->getPrevDeclInScope();
11127 } while (PrevDRDInScope != nullptr);
11129 for (auto &TyData : ReductionTypes) {
11130 auto I = PreviousRedeclTypes.find(TyData.first.getCanonicalType());
11131 bool Invalid = false;
11132 if (I != PreviousRedeclTypes.end()) {
11133 Diag(TyData.second, diag::err_omp_declare_reduction_redefinition)
11135 Diag(I->second, diag::note_previous_definition);
11138 PreviousRedeclTypes[TyData.first.getCanonicalType()] = TyData.second;
11139 auto *DRD = OMPDeclareReductionDecl::Create(Context, DC, TyData.second,
11140 Name, TyData.first, PrevDRD);
11142 DRD->setAccess(AS);
11143 Decls.push_back(DRD);
11145 DRD->setInvalidDecl();
11150 return DeclGroupPtrTy::make(
11151 DeclGroupRef::Create(Context, Decls.begin(), Decls.size()));
11154 void Sema::ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D) {
11155 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11157 // Enter new function scope.
11158 PushFunctionScope();
11159 getCurFunction()->setHasBranchProtectedScope();
11160 getCurFunction()->setHasOMPDeclareReductionCombiner();
11163 PushDeclContext(S, DRD);
11167 PushExpressionEvaluationContext(PotentiallyEvaluated);
11169 QualType ReductionType = DRD->getType();
11170 // Create 'T* omp_parm;T omp_in;'. All references to 'omp_in' will
11171 // be replaced by '*omp_parm' during codegen. This required because 'omp_in'
11172 // uses semantics of argument handles by value, but it should be passed by
11173 // reference. C lang does not support references, so pass all parameters as
11175 // Create 'T omp_in;' variable.
11177 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_in");
11178 // Create 'T* omp_parm;T omp_out;'. All references to 'omp_out' will
11179 // be replaced by '*omp_parm' during codegen. This required because 'omp_out'
11180 // uses semantics of argument handles by value, but it should be passed by
11181 // reference. C lang does not support references, so pass all parameters as
11183 // Create 'T omp_out;' variable.
11185 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_out");
11186 if (S != nullptr) {
11187 PushOnScopeChains(OmpInParm, S);
11188 PushOnScopeChains(OmpOutParm, S);
11190 DRD->addDecl(OmpInParm);
11191 DRD->addDecl(OmpOutParm);
11195 void Sema::ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner) {
11196 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11197 DiscardCleanupsInEvaluationContext();
11198 PopExpressionEvaluationContext();
11201 PopFunctionScopeInfo();
11203 if (Combiner != nullptr)
11204 DRD->setCombiner(Combiner);
11206 DRD->setInvalidDecl();
11209 void Sema::ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D) {
11210 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11212 // Enter new function scope.
11213 PushFunctionScope();
11214 getCurFunction()->setHasBranchProtectedScope();
11217 PushDeclContext(S, DRD);
11221 PushExpressionEvaluationContext(PotentiallyEvaluated);
11223 QualType ReductionType = DRD->getType();
11224 // Create 'T* omp_parm;T omp_priv;'. All references to 'omp_priv' will
11225 // be replaced by '*omp_parm' during codegen. This required because 'omp_priv'
11226 // uses semantics of argument handles by value, but it should be passed by
11227 // reference. C lang does not support references, so pass all parameters as
11229 // Create 'T omp_priv;' variable.
11230 auto *OmpPrivParm =
11231 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_priv");
11232 // Create 'T* omp_parm;T omp_orig;'. All references to 'omp_orig' will
11233 // be replaced by '*omp_parm' during codegen. This required because 'omp_orig'
11234 // uses semantics of argument handles by value, but it should be passed by
11235 // reference. C lang does not support references, so pass all parameters as
11237 // Create 'T omp_orig;' variable.
11238 auto *OmpOrigParm =
11239 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_orig");
11240 if (S != nullptr) {
11241 PushOnScopeChains(OmpPrivParm, S);
11242 PushOnScopeChains(OmpOrigParm, S);
11244 DRD->addDecl(OmpPrivParm);
11245 DRD->addDecl(OmpOrigParm);
11249 void Sema::ActOnOpenMPDeclareReductionInitializerEnd(Decl *D,
11250 Expr *Initializer) {
11251 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11252 DiscardCleanupsInEvaluationContext();
11253 PopExpressionEvaluationContext();
11256 PopFunctionScopeInfo();
11258 if (Initializer != nullptr)
11259 DRD->setInitializer(Initializer);
11261 DRD->setInvalidDecl();
11264 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveEnd(
11265 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid) {
11266 for (auto *D : DeclReductions.get()) {
11268 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11270 PushOnScopeChains(DRD, S, /*AddToContext=*/false);
11272 D->setInvalidDecl();
11274 return DeclReductions;
11277 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams,
11278 SourceLocation StartLoc,
11279 SourceLocation LParenLoc,
11280 SourceLocation EndLoc) {
11281 Expr *ValExpr = NumTeams;
11283 // OpenMP [teams Constrcut, Restrictions]
11284 // The num_teams expression must evaluate to a positive integer value.
11285 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_teams,
11286 /*StrictlyPositive=*/true))
11289 return new (Context) OMPNumTeamsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11292 OMPClause *Sema::ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
11293 SourceLocation StartLoc,
11294 SourceLocation LParenLoc,
11295 SourceLocation EndLoc) {
11296 Expr *ValExpr = ThreadLimit;
11298 // OpenMP [teams Constrcut, Restrictions]
11299 // The thread_limit expression must evaluate to a positive integer value.
11300 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_thread_limit,
11301 /*StrictlyPositive=*/true))
11304 return new (Context) OMPThreadLimitClause(ValExpr, StartLoc, LParenLoc,
11308 OMPClause *Sema::ActOnOpenMPPriorityClause(Expr *Priority,
11309 SourceLocation StartLoc,
11310 SourceLocation LParenLoc,
11311 SourceLocation EndLoc) {
11312 Expr *ValExpr = Priority;
11314 // OpenMP [2.9.1, task Constrcut]
11315 // The priority-value is a non-negative numerical scalar expression.
11316 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_priority,
11317 /*StrictlyPositive=*/false))
11320 return new (Context) OMPPriorityClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11323 OMPClause *Sema::ActOnOpenMPGrainsizeClause(Expr *Grainsize,
11324 SourceLocation StartLoc,
11325 SourceLocation LParenLoc,
11326 SourceLocation EndLoc) {
11327 Expr *ValExpr = Grainsize;
11329 // OpenMP [2.9.2, taskloop Constrcut]
11330 // The parameter of the grainsize clause must be a positive integer
11332 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_grainsize,
11333 /*StrictlyPositive=*/true))
11336 return new (Context) OMPGrainsizeClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11339 OMPClause *Sema::ActOnOpenMPNumTasksClause(Expr *NumTasks,
11340 SourceLocation StartLoc,
11341 SourceLocation LParenLoc,
11342 SourceLocation EndLoc) {
11343 Expr *ValExpr = NumTasks;
11345 // OpenMP [2.9.2, taskloop Constrcut]
11346 // The parameter of the num_tasks clause must be a positive integer
11348 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_tasks,
11349 /*StrictlyPositive=*/true))
11352 return new (Context) OMPNumTasksClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11355 OMPClause *Sema::ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
11356 SourceLocation LParenLoc,
11357 SourceLocation EndLoc) {
11358 // OpenMP [2.13.2, critical construct, Description]
11359 // ... where hint-expression is an integer constant expression that evaluates
11360 // to a valid lock hint.
11361 ExprResult HintExpr = VerifyPositiveIntegerConstantInClause(Hint, OMPC_hint);
11362 if (HintExpr.isInvalid())
11364 return new (Context)
11365 OMPHintClause(HintExpr.get(), StartLoc, LParenLoc, EndLoc);
11368 OMPClause *Sema::ActOnOpenMPDistScheduleClause(
11369 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11370 SourceLocation LParenLoc, SourceLocation KindLoc, SourceLocation CommaLoc,
11371 SourceLocation EndLoc) {
11372 if (Kind == OMPC_DIST_SCHEDULE_unknown) {
11373 std::string Values;
11375 Values += getOpenMPSimpleClauseTypeName(OMPC_dist_schedule, 0);
11377 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
11378 << Values << getOpenMPClauseName(OMPC_dist_schedule);
11381 Expr *ValExpr = ChunkSize;
11382 Stmt *HelperValStmt = nullptr;
11384 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
11385 !ChunkSize->isInstantiationDependent() &&
11386 !ChunkSize->containsUnexpandedParameterPack()) {
11387 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
11389 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
11390 if (Val.isInvalid())
11393 ValExpr = Val.get();
11395 // OpenMP [2.7.1, Restrictions]
11396 // chunk_size must be a loop invariant integer expression with a positive
11398 llvm::APSInt Result;
11399 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
11400 if (Result.isSigned() && !Result.isStrictlyPositive()) {
11401 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
11402 << "dist_schedule" << ChunkSize->getSourceRange();
11405 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
11406 !CurContext->isDependentContext()) {
11407 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
11408 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
11409 HelperValStmt = buildPreInits(Context, Captures);
11414 return new (Context)
11415 OMPDistScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc,
11416 Kind, ValExpr, HelperValStmt);
11419 OMPClause *Sema::ActOnOpenMPDefaultmapClause(
11420 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11421 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11422 SourceLocation KindLoc, SourceLocation EndLoc) {
11423 // OpenMP 4.5 only supports 'defaultmap(tofrom: scalar)'
11424 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom ||
11425 Kind != OMPC_DEFAULTMAP_scalar) {
11427 SourceLocation Loc;
11429 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom) {
11430 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
11431 OMPC_DEFAULTMAP_MODIFIER_tofrom);
11434 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
11435 OMPC_DEFAULTMAP_scalar);
11439 Diag(Loc, diag::err_omp_unexpected_clause_value)
11440 << Value << getOpenMPClauseName(OMPC_defaultmap);
11444 return new (Context)
11445 OMPDefaultmapClause(StartLoc, LParenLoc, MLoc, KindLoc, EndLoc, Kind, M);
11448 bool Sema::ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc) {
11449 DeclContext *CurLexicalContext = getCurLexicalContext();
11450 if (!CurLexicalContext->isFileContext() &&
11451 !CurLexicalContext->isExternCContext() &&
11452 !CurLexicalContext->isExternCXXContext()) {
11453 Diag(Loc, diag::err_omp_region_not_file_context);
11456 if (IsInOpenMPDeclareTargetContext) {
11457 Diag(Loc, diag::err_omp_enclosed_declare_target);
11461 IsInOpenMPDeclareTargetContext = true;
11465 void Sema::ActOnFinishOpenMPDeclareTargetDirective() {
11466 assert(IsInOpenMPDeclareTargetContext &&
11467 "Unexpected ActOnFinishOpenMPDeclareTargetDirective");
11469 IsInOpenMPDeclareTargetContext = false;
11473 Sema::ActOnOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec,
11474 const DeclarationNameInfo &Id,
11475 OMPDeclareTargetDeclAttr::MapTypeTy MT,
11476 NamedDeclSetType &SameDirectiveDecls) {
11477 LookupResult Lookup(*this, Id, LookupOrdinaryName);
11478 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
11480 if (Lookup.isAmbiguous())
11482 Lookup.suppressDiagnostics();
11484 if (!Lookup.isSingleResult()) {
11485 if (TypoCorrection Corrected =
11486 CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr,
11487 llvm::make_unique<VarOrFuncDeclFilterCCC>(*this),
11488 CTK_ErrorRecovery)) {
11489 diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
11491 checkDeclIsAllowedInOpenMPTarget(nullptr, Corrected.getCorrectionDecl());
11495 Diag(Id.getLoc(), diag::err_undeclared_var_use) << Id.getName();
11499 NamedDecl *ND = Lookup.getAsSingle<NamedDecl>();
11500 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
11501 if (!SameDirectiveDecls.insert(cast<NamedDecl>(ND->getCanonicalDecl())))
11502 Diag(Id.getLoc(), diag::err_omp_declare_target_multiple) << Id.getName();
11504 if (!ND->hasAttr<OMPDeclareTargetDeclAttr>()) {
11505 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(Context, MT);
11507 if (ASTMutationListener *ML = Context.getASTMutationListener())
11508 ML->DeclarationMarkedOpenMPDeclareTarget(ND, A);
11509 checkDeclIsAllowedInOpenMPTarget(nullptr, ND);
11510 } else if (ND->getAttr<OMPDeclareTargetDeclAttr>()->getMapType() != MT) {
11511 Diag(Id.getLoc(), diag::err_omp_declare_target_to_and_link)
11515 Diag(Id.getLoc(), diag::err_omp_invalid_target_decl) << Id.getName();
11518 static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR,
11519 Sema &SemaRef, Decl *D) {
11522 Decl *LD = nullptr;
11523 if (isa<TagDecl>(D)) {
11524 LD = cast<TagDecl>(D)->getDefinition();
11525 } else if (isa<VarDecl>(D)) {
11526 LD = cast<VarDecl>(D)->getDefinition();
11528 // If this is an implicit variable that is legal and we do not need to do
11530 if (cast<VarDecl>(D)->isImplicit()) {
11531 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11532 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11534 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11535 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11539 } else if (isa<FunctionDecl>(D)) {
11540 const FunctionDecl *FD = nullptr;
11541 if (cast<FunctionDecl>(D)->hasBody(FD))
11542 LD = const_cast<FunctionDecl *>(FD);
11544 // If the definition is associated with the current declaration in the
11545 // target region (it can be e.g. a lambda) that is legal and we do not need
11546 // to do anything else.
11548 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11549 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11551 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11552 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11558 if (LD && !LD->hasAttr<OMPDeclareTargetDeclAttr>() &&
11559 (isa<VarDecl>(LD) || isa<FunctionDecl>(LD))) {
11560 // Outlined declaration is not declared target.
11561 if (LD->isOutOfLine()) {
11562 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
11563 SemaRef.Diag(SL, diag::note_used_here) << SR;
11565 DeclContext *DC = LD->getDeclContext();
11567 if (isa<FunctionDecl>(DC) &&
11568 cast<FunctionDecl>(DC)->hasAttr<OMPDeclareTargetDeclAttr>())
11570 DC = DC->getParent();
11575 // Is not declared in target context.
11576 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
11577 SemaRef.Diag(SL, diag::note_used_here) << SR;
11579 // Mark decl as declared target to prevent further diagnostic.
11580 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11581 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11583 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11584 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11588 static bool checkValueDeclInTarget(SourceLocation SL, SourceRange SR,
11589 Sema &SemaRef, DSAStackTy *Stack,
11591 if (VD->hasAttr<OMPDeclareTargetDeclAttr>())
11593 if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType()))
11598 void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) {
11599 if (!D || D->isInvalidDecl())
11601 SourceRange SR = E ? E->getSourceRange() : D->getSourceRange();
11602 SourceLocation SL = E ? E->getLocStart() : D->getLocation();
11603 // 2.10.6: threadprivate variable cannot appear in a declare target directive.
11604 if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
11605 if (DSAStack->isThreadPrivate(VD)) {
11606 Diag(SL, diag::err_omp_threadprivate_in_target);
11607 ReportOriginalDSA(*this, DSAStack, VD, DSAStack->getTopDSA(VD, false));
11611 if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
11612 // Problem if any with var declared with incomplete type will be reported
11613 // as normal, so no need to check it here.
11614 if ((E || !VD->getType()->isIncompleteType()) &&
11615 !checkValueDeclInTarget(SL, SR, *this, DSAStack, VD)) {
11616 // Mark decl as declared target to prevent further diagnostic.
11617 if (isa<VarDecl>(VD) || isa<FunctionDecl>(VD)) {
11618 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11619 Context, OMPDeclareTargetDeclAttr::MT_To);
11621 if (ASTMutationListener *ML = Context.getASTMutationListener())
11622 ML->DeclarationMarkedOpenMPDeclareTarget(VD, A);
11628 // Checking declaration inside declare target region.
11629 if (!D->hasAttr<OMPDeclareTargetDeclAttr>() &&
11630 (isa<VarDecl>(D) || isa<FunctionDecl>(D))) {
11631 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11632 Context, OMPDeclareTargetDeclAttr::MT_To);
11634 if (ASTMutationListener *ML = Context.getASTMutationListener())
11635 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11639 checkDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this, D);
11642 OMPClause *Sema::ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
11643 SourceLocation StartLoc,
11644 SourceLocation LParenLoc,
11645 SourceLocation EndLoc) {
11646 MappableVarListInfo MVLI(VarList);
11647 checkMappableExpressionList(*this, DSAStack, OMPC_to, MVLI, StartLoc);
11648 if (MVLI.ProcessedVarList.empty())
11651 return OMPToClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11652 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11653 MVLI.VarComponents);
11656 OMPClause *Sema::ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
11657 SourceLocation StartLoc,
11658 SourceLocation LParenLoc,
11659 SourceLocation EndLoc) {
11660 MappableVarListInfo MVLI(VarList);
11661 checkMappableExpressionList(*this, DSAStack, OMPC_from, MVLI, StartLoc);
11662 if (MVLI.ProcessedVarList.empty())
11665 return OMPFromClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11666 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11667 MVLI.VarComponents);
11670 OMPClause *Sema::ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
11671 SourceLocation StartLoc,
11672 SourceLocation LParenLoc,
11673 SourceLocation EndLoc) {
11674 SmallVector<Expr *, 8> Vars;
11675 for (auto &RefExpr : VarList) {
11676 assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause.");
11677 SourceLocation ELoc;
11678 SourceRange ERange;
11679 Expr *SimpleRefExpr = RefExpr;
11680 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11682 // It will be analyzed later.
11683 Vars.push_back(RefExpr);
11685 ValueDecl *D = Res.first;
11689 QualType Type = D->getType();
11690 // item should be a pointer or reference to pointer
11691 if (!Type.getNonReferenceType()->isPointerType()) {
11692 Diag(ELoc, diag::err_omp_usedeviceptr_not_a_pointer)
11693 << 0 << RefExpr->getSourceRange();
11696 Vars.push_back(RefExpr->IgnoreParens());
11702 return OMPUseDevicePtrClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11706 OMPClause *Sema::ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11707 SourceLocation StartLoc,
11708 SourceLocation LParenLoc,
11709 SourceLocation EndLoc) {
11710 SmallVector<Expr *, 8> Vars;
11711 for (auto &RefExpr : VarList) {
11712 assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause.");
11713 SourceLocation ELoc;
11714 SourceRange ERange;
11715 Expr *SimpleRefExpr = RefExpr;
11716 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11718 // It will be analyzed later.
11719 Vars.push_back(RefExpr);
11721 ValueDecl *D = Res.first;
11725 QualType Type = D->getType();
11726 // item should be a pointer or array or reference to pointer or array
11727 if (!Type.getNonReferenceType()->isPointerType() &&
11728 !Type.getNonReferenceType()->isArrayType()) {
11729 Diag(ELoc, diag::err_omp_argument_type_isdeviceptr)
11730 << 0 << RefExpr->getSourceRange();
11733 Vars.push_back(RefExpr->IgnoreParens());
11739 return OMPIsDevicePtrClause::Create(Context, StartLoc, LParenLoc, EndLoc,