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 /// Struct that associates a component with the clause kind where they are
77 struct MappedExprComponentTy {
78 OMPClauseMappableExprCommon::MappableExprComponentLists Components;
79 OpenMPClauseKind Kind = OMPC_unknown;
81 typedef llvm::DenseMap<ValueDecl *, MappedExprComponentTy>
82 MappedExprComponentsTy;
83 typedef llvm::StringMap<std::pair<OMPCriticalDirective *, llvm::APSInt>>
85 typedef llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>
88 struct SharingMapTy final {
89 DeclSAMapTy SharingMap;
90 AlignedMapTy AlignedMap;
91 MappedExprComponentsTy MappedExprComponents;
92 LoopControlVariablesMapTy LCVMap;
93 DefaultDataSharingAttributes DefaultAttr = DSA_unspecified;
94 SourceLocation DefaultAttrLoc;
95 OpenMPDirectiveKind Directive = OMPD_unknown;
96 DeclarationNameInfo DirectiveName;
97 Scope *CurScope = nullptr;
98 SourceLocation ConstructLoc;
99 /// Set of 'depend' clauses with 'sink|source' dependence kind. Required to
100 /// get the data (loop counters etc.) about enclosing loop-based construct.
101 /// This data is required during codegen.
102 DoacrossDependMapTy DoacrossDepends;
103 /// \brief first argument (Expr *) contains optional argument of the
104 /// 'ordered' clause, the second one is true if the regions has 'ordered'
105 /// clause, false otherwise.
106 llvm::PointerIntPair<Expr *, 1, bool> OrderedRegion;
107 bool NowaitRegion = false;
108 bool CancelRegion = false;
109 unsigned AssociatedLoops = 1;
110 SourceLocation InnerTeamsRegionLoc;
111 SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name,
112 Scope *CurScope, SourceLocation Loc)
113 : Directive(DKind), DirectiveName(Name), CurScope(CurScope),
118 typedef SmallVector<SharingMapTy, 4> StackTy;
120 /// \brief Stack of used declaration and their data-sharing attributes.
122 /// \brief true, if check for DSA must be from parent directive, false, if
123 /// from current directive.
124 OpenMPClauseKind ClauseKindMode = OMPC_unknown;
126 bool ForceCapturing = false;
127 CriticalsWithHintsTy Criticals;
129 typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator;
131 DSAVarData getDSA(StackTy::reverse_iterator &Iter, ValueDecl *D);
133 /// \brief Checks if the variable is a local for OpenMP region.
134 bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter);
137 explicit DSAStackTy(Sema &S) : Stack(1), SemaRef(S) {}
139 bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
140 void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }
142 bool isForceVarCapturing() const { return ForceCapturing; }
143 void setForceVarCapturing(bool V) { ForceCapturing = V; }
145 void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
146 Scope *CurScope, SourceLocation Loc) {
147 Stack.push_back(SharingMapTy(DKind, DirName, CurScope, Loc));
148 Stack.back().DefaultAttrLoc = Loc;
152 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!");
156 void addCriticalWithHint(OMPCriticalDirective *D, llvm::APSInt Hint) {
157 Criticals[D->getDirectiveName().getAsString()] = std::make_pair(D, Hint);
159 const std::pair<OMPCriticalDirective *, llvm::APSInt>
160 getCriticalWithHint(const DeclarationNameInfo &Name) const {
161 auto I = Criticals.find(Name.getAsString());
162 if (I != Criticals.end())
164 return std::make_pair(nullptr, llvm::APSInt());
166 /// \brief If 'aligned' declaration for given variable \a D was not seen yet,
167 /// add it and return NULL; otherwise return previous occurrence's expression
169 Expr *addUniqueAligned(ValueDecl *D, Expr *NewDE);
171 /// \brief Register specified variable as loop control variable.
172 void addLoopControlVariable(ValueDecl *D, VarDecl *Capture);
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 isLoopControlVariable(ValueDecl *D);
178 /// \brief Check if the specified variable is a loop control variable for
180 /// \return The index of the loop control variable in the list of associated
181 /// for-loops (from outer to inner).
182 LCDeclInfo isParentLoopControlVariable(ValueDecl *D);
183 /// \brief Get the loop control variable for the I-th loop (or nullptr) in
184 /// parent directive.
185 ValueDecl *getParentLoopControlVariable(unsigned I);
187 /// \brief Adds explicit data sharing attribute to the specified declaration.
188 void addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
189 DeclRefExpr *PrivateCopy = nullptr);
191 /// \brief Returns data sharing attributes from top of the stack for the
192 /// specified declaration.
193 DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
194 /// \brief Returns data-sharing attributes for the specified declaration.
195 DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent);
196 /// \brief Checks if the specified variables has data-sharing attributes which
197 /// match specified \a CPred predicate in any directive which matches \a DPred
199 DSAVarData hasDSA(ValueDecl *D,
200 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
201 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
203 /// \brief Checks if the specified variables has data-sharing attributes which
204 /// match specified \a CPred predicate in any innermost directive which
205 /// matches \a DPred predicate.
207 hasInnermostDSA(ValueDecl *D,
208 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
209 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
211 /// \brief Checks if the specified variables has explicit data-sharing
212 /// attributes which match specified \a CPred predicate at the specified
214 bool hasExplicitDSA(ValueDecl *D,
215 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
216 unsigned Level, bool NotLastprivate = false);
218 /// \brief Returns true if the directive at level \Level matches in the
219 /// specified \a DPred predicate.
220 bool hasExplicitDirective(
221 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
224 /// \brief Finds a directive which matches specified \a DPred predicate.
225 bool hasDirective(const llvm::function_ref<bool(OpenMPDirectiveKind,
226 const DeclarationNameInfo &,
227 SourceLocation)> &DPred,
230 /// \brief Returns currently analyzed directive.
231 OpenMPDirectiveKind getCurrentDirective() const {
232 return Stack.back().Directive;
234 /// \brief Returns parent directive.
235 OpenMPDirectiveKind getParentDirective() const {
236 if (Stack.size() > 2)
237 return Stack[Stack.size() - 2].Directive;
241 /// \brief Set default data sharing attribute to none.
242 void setDefaultDSANone(SourceLocation Loc) {
243 Stack.back().DefaultAttr = DSA_none;
244 Stack.back().DefaultAttrLoc = Loc;
246 /// \brief Set default data sharing attribute to shared.
247 void setDefaultDSAShared(SourceLocation Loc) {
248 Stack.back().DefaultAttr = DSA_shared;
249 Stack.back().DefaultAttrLoc = Loc;
252 DefaultDataSharingAttributes getDefaultDSA() const {
253 return Stack.back().DefaultAttr;
255 SourceLocation getDefaultDSALocation() const {
256 return Stack.back().DefaultAttrLoc;
259 /// \brief Checks if the specified variable is a threadprivate.
260 bool isThreadPrivate(VarDecl *D) {
261 DSAVarData DVar = getTopDSA(D, false);
262 return isOpenMPThreadPrivate(DVar.CKind);
265 /// \brief Marks current region as ordered (it has an 'ordered' clause).
266 void setOrderedRegion(bool IsOrdered, Expr *Param) {
267 Stack.back().OrderedRegion.setInt(IsOrdered);
268 Stack.back().OrderedRegion.setPointer(Param);
270 /// \brief Returns true, if parent region is ordered (has associated
271 /// 'ordered' clause), false - otherwise.
272 bool isParentOrderedRegion() const {
273 if (Stack.size() > 2)
274 return Stack[Stack.size() - 2].OrderedRegion.getInt();
277 /// \brief Returns optional parameter for the ordered region.
278 Expr *getParentOrderedRegionParam() const {
279 if (Stack.size() > 2)
280 return Stack[Stack.size() - 2].OrderedRegion.getPointer();
283 /// \brief Marks current region as nowait (it has a 'nowait' clause).
284 void setNowaitRegion(bool IsNowait = true) {
285 Stack.back().NowaitRegion = IsNowait;
287 /// \brief Returns true, if parent region is nowait (has associated
288 /// 'nowait' clause), false - otherwise.
289 bool isParentNowaitRegion() const {
290 if (Stack.size() > 2)
291 return Stack[Stack.size() - 2].NowaitRegion;
294 /// \brief Marks parent region as cancel region.
295 void setParentCancelRegion(bool Cancel = true) {
296 if (Stack.size() > 2)
297 Stack[Stack.size() - 2].CancelRegion =
298 Stack[Stack.size() - 2].CancelRegion || Cancel;
300 /// \brief Return true if current region has inner cancel construct.
301 bool isCancelRegion() const { return Stack.back().CancelRegion; }
303 /// \brief Set collapse value for the region.
304 void setAssociatedLoops(unsigned Val) { Stack.back().AssociatedLoops = Val; }
305 /// \brief Return collapse value for region.
306 unsigned getAssociatedLoops() const { return Stack.back().AssociatedLoops; }
308 /// \brief Marks current target region as one with closely nested teams
310 void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
311 if (Stack.size() > 2)
312 Stack[Stack.size() - 2].InnerTeamsRegionLoc = TeamsRegionLoc;
314 /// \brief Returns true, if current region has closely nested teams region.
315 bool hasInnerTeamsRegion() const {
316 return getInnerTeamsRegionLoc().isValid();
318 /// \brief Returns location of the nested teams region (if any).
319 SourceLocation getInnerTeamsRegionLoc() const {
320 if (Stack.size() > 1)
321 return Stack.back().InnerTeamsRegionLoc;
322 return SourceLocation();
325 Scope *getCurScope() const { return Stack.back().CurScope; }
326 Scope *getCurScope() { return Stack.back().CurScope; }
327 SourceLocation getConstructLoc() { return Stack.back().ConstructLoc; }
329 /// Do the check specified in \a Check to all component lists and return true
330 /// if any issue is found.
331 bool checkMappableExprComponentListsForDecl(
332 ValueDecl *VD, bool CurrentRegionOnly,
333 const llvm::function_ref<
334 bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
335 OpenMPClauseKind)> &Check) {
336 auto SI = Stack.rbegin();
337 auto SE = Stack.rend();
342 if (CurrentRegionOnly) {
348 for (; SI != SE; ++SI) {
349 auto MI = SI->MappedExprComponents.find(VD);
350 if (MI != SI->MappedExprComponents.end())
351 for (auto &L : MI->second.Components)
352 if (Check(L, MI->second.Kind))
358 /// Create a new mappable expression component list associated with a given
359 /// declaration and initialize it with the provided list of components.
360 void addMappableExpressionComponents(
362 OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
363 OpenMPClauseKind WhereFoundClauseKind) {
364 assert(Stack.size() > 1 &&
365 "Not expecting to retrieve components from a empty stack!");
366 auto &MEC = Stack.back().MappedExprComponents[VD];
367 // Create new entry and append the new components there.
368 MEC.Components.resize(MEC.Components.size() + 1);
369 MEC.Components.back().append(Components.begin(), Components.end());
370 MEC.Kind = WhereFoundClauseKind;
373 unsigned getNestingLevel() const {
374 assert(Stack.size() > 1);
375 return Stack.size() - 2;
377 void addDoacrossDependClause(OMPDependClause *C, OperatorOffsetTy &OpsOffs) {
378 assert(Stack.size() > 2);
379 assert(isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive));
380 Stack[Stack.size() - 2].DoacrossDepends.insert({C, OpsOffs});
382 llvm::iterator_range<DoacrossDependMapTy::const_iterator>
383 getDoacrossDependClauses() const {
384 assert(Stack.size() > 1);
385 if (isOpenMPWorksharingDirective(Stack[Stack.size() - 1].Directive)) {
386 auto &Ref = Stack[Stack.size() - 1].DoacrossDepends;
387 return llvm::make_range(Ref.begin(), Ref.end());
389 return llvm::make_range(Stack[0].DoacrossDepends.end(),
390 Stack[0].DoacrossDepends.end());
393 bool isParallelOrTaskRegion(OpenMPDirectiveKind DKind) {
394 return isOpenMPParallelDirective(DKind) || isOpenMPTaskingDirective(DKind) ||
395 isOpenMPTeamsDirective(DKind) || DKind == OMPD_unknown;
399 static ValueDecl *getCanonicalDecl(ValueDecl *D) {
400 auto *VD = dyn_cast<VarDecl>(D);
401 auto *FD = dyn_cast<FieldDecl>(D);
403 VD = VD->getCanonicalDecl();
407 FD = FD->getCanonicalDecl();
413 DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator &Iter,
415 D = getCanonicalDecl(D);
416 auto *VD = dyn_cast<VarDecl>(D);
417 auto *FD = dyn_cast<FieldDecl>(D);
419 if (Iter == std::prev(Stack.rend())) {
420 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
421 // in a region but not in construct]
422 // File-scope or namespace-scope variables referenced in called routines
423 // in the region are shared unless they appear in a threadprivate
425 if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(D))
426 DVar.CKind = OMPC_shared;
428 // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
429 // in a region but not in construct]
430 // Variables with static storage duration that are declared in called
431 // routines in the region are shared.
432 if (VD && VD->hasGlobalStorage())
433 DVar.CKind = OMPC_shared;
435 // Non-static data members are shared by default.
437 DVar.CKind = OMPC_shared;
442 DVar.DKind = Iter->Directive;
443 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
444 // in a Construct, C/C++, predetermined, p.1]
445 // Variables with automatic storage duration that are declared in a scope
446 // inside the construct are private.
447 if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
448 (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
449 DVar.CKind = OMPC_private;
453 // Explicitly specified attributes and local variables with predetermined
455 if (Iter->SharingMap.count(D)) {
456 DVar.RefExpr = Iter->SharingMap[D].RefExpr.getPointer();
457 DVar.PrivateCopy = Iter->SharingMap[D].PrivateCopy;
458 DVar.CKind = Iter->SharingMap[D].Attributes;
459 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
463 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
464 // in a Construct, C/C++, implicitly determined, p.1]
465 // In a parallel or task construct, the data-sharing attributes of these
466 // variables are determined by the default clause, if present.
467 switch (Iter->DefaultAttr) {
469 DVar.CKind = OMPC_shared;
470 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
474 case DSA_unspecified:
475 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
476 // in a Construct, implicitly determined, p.2]
477 // In a parallel construct, if no default clause is present, these
478 // variables are shared.
479 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
480 if (isOpenMPParallelDirective(DVar.DKind) ||
481 isOpenMPTeamsDirective(DVar.DKind)) {
482 DVar.CKind = OMPC_shared;
486 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
487 // in a Construct, implicitly determined, p.4]
488 // In a task construct, if no default clause is present, a variable that in
489 // the enclosing context is determined to be shared by all implicit tasks
490 // bound to the current team is shared.
491 if (isOpenMPTaskingDirective(DVar.DKind)) {
493 for (StackTy::reverse_iterator I = std::next(Iter), EE = Stack.rend();
495 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
496 // Referenced in a Construct, implicitly determined, p.6]
497 // In a task construct, if no default clause is present, a variable
498 // whose data-sharing attribute is not determined by the rules above is
500 DVarTemp = getDSA(I, D);
501 if (DVarTemp.CKind != OMPC_shared) {
502 DVar.RefExpr = nullptr;
503 DVar.CKind = OMPC_firstprivate;
506 if (isParallelOrTaskRegion(I->Directive))
510 (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
514 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
515 // in a Construct, implicitly determined, p.3]
516 // For constructs other than task, if no default clause is present, these
517 // variables inherit their data-sharing attributes from the enclosing
519 return getDSA(++Iter, D);
522 Expr *DSAStackTy::addUniqueAligned(ValueDecl *D, Expr *NewDE) {
523 assert(Stack.size() > 1 && "Data sharing attributes stack is empty");
524 D = getCanonicalDecl(D);
525 auto It = Stack.back().AlignedMap.find(D);
526 if (It == Stack.back().AlignedMap.end()) {
527 assert(NewDE && "Unexpected nullptr expr to be added into aligned map");
528 Stack.back().AlignedMap[D] = NewDE;
531 assert(It->second && "Unexpected nullptr expr in the aligned map");
537 void DSAStackTy::addLoopControlVariable(ValueDecl *D, VarDecl *Capture) {
538 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
539 D = getCanonicalDecl(D);
540 Stack.back().LCVMap.insert(
541 std::make_pair(D, LCDeclInfo(Stack.back().LCVMap.size() + 1, Capture)));
544 DSAStackTy::LCDeclInfo DSAStackTy::isLoopControlVariable(ValueDecl *D) {
545 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
546 D = getCanonicalDecl(D);
547 return Stack.back().LCVMap.count(D) > 0 ? Stack.back().LCVMap[D]
548 : LCDeclInfo(0, nullptr);
551 DSAStackTy::LCDeclInfo DSAStackTy::isParentLoopControlVariable(ValueDecl *D) {
552 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty");
553 D = getCanonicalDecl(D);
554 return Stack[Stack.size() - 2].LCVMap.count(D) > 0
555 ? Stack[Stack.size() - 2].LCVMap[D]
556 : LCDeclInfo(0, nullptr);
559 ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) {
560 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty");
561 if (Stack[Stack.size() - 2].LCVMap.size() < I)
563 for (auto &Pair : Stack[Stack.size() - 2].LCVMap) {
564 if (Pair.second.first == I)
570 void DSAStackTy::addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
571 DeclRefExpr *PrivateCopy) {
572 D = getCanonicalDecl(D);
573 if (A == OMPC_threadprivate) {
574 auto &Data = Stack[0].SharingMap[D];
576 Data.RefExpr.setPointer(E);
577 Data.PrivateCopy = nullptr;
579 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty");
580 auto &Data = Stack.back().SharingMap[D];
581 assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
582 (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||
583 (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||
584 (isLoopControlVariable(D).first && A == OMPC_private));
585 if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
586 Data.RefExpr.setInt(/*IntVal=*/true);
589 const bool IsLastprivate =
590 A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
592 Data.RefExpr.setPointerAndInt(E, IsLastprivate);
593 Data.PrivateCopy = PrivateCopy;
595 auto &Data = Stack.back().SharingMap[PrivateCopy->getDecl()];
597 Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
598 Data.PrivateCopy = nullptr;
603 bool DSAStackTy::isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter) {
604 D = D->getCanonicalDecl();
605 if (Stack.size() > 2) {
606 reverse_iterator I = Iter, E = std::prev(Stack.rend());
607 Scope *TopScope = nullptr;
608 while (I != E && !isParallelOrTaskRegion(I->Directive)) {
613 TopScope = I->CurScope ? I->CurScope->getParent() : nullptr;
614 Scope *CurScope = getCurScope();
615 while (CurScope != TopScope && !CurScope->isDeclScope(D)) {
616 CurScope = CurScope->getParent();
618 return CurScope != TopScope;
623 /// \brief Build a variable declaration for OpenMP loop iteration variable.
624 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
625 StringRef Name, const AttrVec *Attrs = nullptr) {
626 DeclContext *DC = SemaRef.CurContext;
627 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
628 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
630 VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
632 for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
640 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
642 bool RefersToCapture = false) {
644 D->markUsed(S.Context);
645 return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
646 SourceLocation(), D, RefersToCapture, Loc, Ty,
650 DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D, bool FromParent) {
651 D = getCanonicalDecl(D);
654 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
655 // in a Construct, C/C++, predetermined, p.1]
656 // Variables appearing in threadprivate directives are threadprivate.
657 auto *VD = dyn_cast<VarDecl>(D);
658 if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
659 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
660 SemaRef.getLangOpts().OpenMPUseTLS &&
661 SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
662 (VD && VD->getStorageClass() == SC_Register &&
663 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
664 addDSA(D, buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
668 if (Stack[0].SharingMap.count(D)) {
669 DVar.RefExpr = Stack[0].SharingMap[D].RefExpr.getPointer();
670 DVar.CKind = OMPC_threadprivate;
674 if (Stack.size() == 1) {
675 // Not in OpenMP execution region and top scope was already checked.
679 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
680 // in a Construct, C/C++, predetermined, p.4]
681 // Static data members are shared.
682 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
683 // in a Construct, C/C++, predetermined, p.7]
684 // Variables with static storage duration that are declared in a scope
685 // inside the construct are shared.
686 auto &&MatchesAlways = [](OpenMPDirectiveKind) -> bool { return true; };
687 if (VD && VD->isStaticDataMember()) {
688 DSAVarData DVarTemp = hasDSA(D, isOpenMPPrivate, MatchesAlways, FromParent);
689 if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
692 DVar.CKind = OMPC_shared;
696 QualType Type = D->getType().getNonReferenceType().getCanonicalType();
697 bool IsConstant = Type.isConstant(SemaRef.getASTContext());
698 Type = SemaRef.getASTContext().getBaseElementType(Type);
699 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
700 // in a Construct, C/C++, predetermined, p.6]
701 // Variables with const qualified type having no mutable member are
704 SemaRef.getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr;
705 if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
706 if (auto *CTD = CTSD->getSpecializedTemplate())
707 RD = CTD->getTemplatedDecl();
709 !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() &&
710 RD->hasMutableFields())) {
711 // Variables with const-qualified type having no mutable member may be
712 // listed in a firstprivate clause, even if they are static data members.
713 DSAVarData DVarTemp = hasDSA(
714 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_firstprivate; },
715 MatchesAlways, FromParent);
716 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr)
719 DVar.CKind = OMPC_shared;
723 // Explicitly specified attributes and local variables with predetermined
725 auto StartI = std::next(Stack.rbegin());
726 auto EndI = std::prev(Stack.rend());
727 if (FromParent && StartI != EndI) {
728 StartI = std::next(StartI);
730 auto I = std::prev(StartI);
731 if (I->SharingMap.count(D)) {
732 DVar.RefExpr = I->SharingMap[D].RefExpr.getPointer();
733 DVar.PrivateCopy = I->SharingMap[D].PrivateCopy;
734 DVar.CKind = I->SharingMap[D].Attributes;
735 DVar.ImplicitDSALoc = I->DefaultAttrLoc;
741 DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
743 D = getCanonicalDecl(D);
744 auto StartI = Stack.rbegin();
745 auto EndI = std::prev(Stack.rend());
746 if (FromParent && StartI != EndI) {
747 StartI = std::next(StartI);
749 return getDSA(StartI, D);
752 DSAStackTy::DSAVarData
753 DSAStackTy::hasDSA(ValueDecl *D,
754 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
755 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
757 D = getCanonicalDecl(D);
758 auto StartI = std::next(Stack.rbegin());
759 auto EndI = Stack.rend();
760 if (FromParent && StartI != EndI) {
761 StartI = std::next(StartI);
763 for (auto I = StartI, EE = EndI; I != EE; ++I) {
764 if (!DPred(I->Directive) && !isParallelOrTaskRegion(I->Directive))
766 DSAVarData DVar = getDSA(I, D);
767 if (CPred(DVar.CKind))
773 DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
774 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
775 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
777 D = getCanonicalDecl(D);
778 auto StartI = std::next(Stack.rbegin());
779 auto EndI = Stack.rend();
780 if (FromParent && StartI != EndI)
781 StartI = std::next(StartI);
782 if (StartI == EndI || !DPred(StartI->Directive))
784 DSAVarData DVar = getDSA(StartI, D);
785 return CPred(DVar.CKind) ? DVar : DSAVarData();
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.
906 if (Ty->isReferenceType())
907 Ty = Ty->castAs<ReferenceType>()->getPointeeType();
909 // Locate map clauses and see if the variable being captured is referred to
910 // in any of those clauses. Here we only care about variables, not fields,
911 // because fields are part of aggregates.
912 bool IsVariableUsedInMapClause = false;
913 bool IsVariableAssociatedWithSection = false;
915 DSAStack->checkMappableExprComponentListsForDecl(
916 D, /*CurrentRegionOnly=*/true,
917 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
919 OpenMPClauseKind WhereFoundClauseKind) {
920 // Only the map clause information influences how a variable is
921 // captured. E.g. is_device_ptr does not require changing the default
923 if (WhereFoundClauseKind != OMPC_map)
926 auto EI = MapExprComponents.rbegin();
927 auto EE = MapExprComponents.rend();
929 assert(EI != EE && "Invalid map expression!");
931 if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
932 IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
938 if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
939 isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
940 isa<MemberExpr>(EI->getAssociatedExpression())) {
941 IsVariableAssociatedWithSection = true;
942 // There is nothing more we need to know about this variable.
946 // Keep looking for more map info.
950 if (IsVariableUsedInMapClause) {
951 // If variable is identified in a map clause it is always captured by
952 // reference except if it is a pointer that is dereferenced somehow.
953 IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
955 // By default, all the data that has a scalar type is mapped by copy.
956 IsByRef = !Ty->isScalarType();
960 if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
961 IsByRef = !DSAStack->hasExplicitDSA(
962 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_firstprivate; },
963 Level, /*NotLastprivate=*/true);
966 // When passing data by copy, we need to make sure it fits the uintptr size
967 // and alignment, because the runtime library only deals with uintptr types.
968 // If it does not fit the uintptr size, we need to pass the data by reference
971 (Ctx.getTypeSizeInChars(Ty) >
972 Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
973 Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
980 unsigned Sema::getOpenMPNestingLevel() const {
981 assert(getLangOpts().OpenMP);
982 return DSAStack->getNestingLevel();
985 VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) {
986 assert(LangOpts.OpenMP && "OpenMP is not allowed");
987 D = getCanonicalDecl(D);
989 // If we are attempting to capture a global variable in a directive with
990 // 'target' we return true so that this global is also mapped to the device.
992 // FIXME: If the declaration is enclosed in a 'declare target' directive,
993 // then it should not be captured. Therefore, an extra check has to be
994 // inserted here once support for 'declare target' is added.
996 auto *VD = dyn_cast<VarDecl>(D);
997 if (VD && !VD->hasLocalStorage()) {
998 if (DSAStack->getCurrentDirective() == OMPD_target &&
999 !DSAStack->isClauseParsingMode())
1001 if (DSAStack->hasDirective(
1002 [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
1003 SourceLocation) -> bool {
1004 return isOpenMPTargetExecutionDirective(K);
1010 if (DSAStack->getCurrentDirective() != OMPD_unknown &&
1011 (!DSAStack->isClauseParsingMode() ||
1012 DSAStack->getParentDirective() != OMPD_unknown)) {
1013 auto &&Info = DSAStack->isLoopControlVariable(D);
1015 (VD && VD->hasLocalStorage() &&
1016 isParallelOrTaskRegion(DSAStack->getCurrentDirective())) ||
1017 (VD && DSAStack->isForceVarCapturing()))
1018 return VD ? VD : Info.second;
1019 auto DVarPrivate = DSAStack->getTopDSA(D, DSAStack->isClauseParsingMode());
1020 if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind))
1021 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1022 DVarPrivate = DSAStack->hasDSA(
1023 D, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
1024 DSAStack->isClauseParsingMode());
1025 if (DVarPrivate.CKind != OMPC_unknown)
1026 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1031 bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) {
1032 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1033 return DSAStack->hasExplicitDSA(
1034 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level);
1037 bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) {
1038 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1039 // Return true if the current level is no longer enclosed in a target region.
1041 auto *VD = dyn_cast<VarDecl>(D);
1042 return VD && !VD->hasLocalStorage() &&
1043 DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
1047 void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; }
1049 void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
1050 const DeclarationNameInfo &DirName,
1051 Scope *CurScope, SourceLocation Loc) {
1052 DSAStack->push(DKind, DirName, CurScope, Loc);
1053 PushExpressionEvaluationContext(PotentiallyEvaluated);
1056 void Sema::StartOpenMPClause(OpenMPClauseKind K) {
1057 DSAStack->setClauseParsingMode(K);
1060 void Sema::EndOpenMPClause() {
1061 DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown);
1064 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
1065 // OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
1066 // A variable of class type (or array thereof) that appears in a lastprivate
1067 // clause requires an accessible, unambiguous default constructor for the
1068 // class type, unless the list item is also specified in a firstprivate
1070 if (auto *D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
1071 for (auto *C : D->clauses()) {
1072 if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
1073 SmallVector<Expr *, 8> PrivateCopies;
1074 for (auto *DE : Clause->varlists()) {
1075 if (DE->isValueDependent() || DE->isTypeDependent()) {
1076 PrivateCopies.push_back(nullptr);
1079 auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
1080 VarDecl *VD = cast<VarDecl>(DRE->getDecl());
1081 QualType Type = VD->getType().getNonReferenceType();
1082 auto DVar = DSAStack->getTopDSA(VD, false);
1083 if (DVar.CKind == OMPC_lastprivate) {
1084 // Generate helper private variable and initialize it with the
1085 // default value. The address of the original variable is replaced
1086 // by the address of the new private variable in CodeGen. This new
1087 // variable is not added to IdResolver, so the code in the OpenMP
1088 // region uses original variable for proper diagnostics.
1089 auto *VDPrivate = buildVarDecl(
1090 *this, DE->getExprLoc(), Type.getUnqualifiedType(),
1091 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr);
1092 ActOnUninitializedDecl(VDPrivate);
1093 if (VDPrivate->isInvalidDecl())
1095 PrivateCopies.push_back(buildDeclRefExpr(
1096 *this, VDPrivate, DE->getType(), DE->getExprLoc()));
1098 // The variable is also a firstprivate, so initialization sequence
1099 // for private copy is generated already.
1100 PrivateCopies.push_back(nullptr);
1103 // Set initializers to private copies if no errors were found.
1104 if (PrivateCopies.size() == Clause->varlist_size())
1105 Clause->setPrivateCopies(PrivateCopies);
1111 DiscardCleanupsInEvaluationContext();
1112 PopExpressionEvaluationContext();
1115 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1116 Expr *NumIterations, Sema &SemaRef,
1117 Scope *S, DSAStackTy *Stack);
1121 class VarDeclFilterCCC : public CorrectionCandidateCallback {
1126 explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
1127 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1128 NamedDecl *ND = Candidate.getCorrectionDecl();
1129 if (auto *VD = dyn_cast_or_null<VarDecl>(ND)) {
1130 return VD->hasGlobalStorage() &&
1131 SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1132 SemaRef.getCurScope());
1138 class VarOrFuncDeclFilterCCC : public CorrectionCandidateCallback {
1143 explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
1144 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1145 NamedDecl *ND = Candidate.getCorrectionDecl();
1146 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
1147 return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1148 SemaRef.getCurScope());
1156 ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
1157 CXXScopeSpec &ScopeSpec,
1158 const DeclarationNameInfo &Id) {
1159 LookupResult Lookup(*this, Id, LookupOrdinaryName);
1160 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
1162 if (Lookup.isAmbiguous())
1166 if (!Lookup.isSingleResult()) {
1167 if (TypoCorrection Corrected = CorrectTypo(
1168 Id, LookupOrdinaryName, CurScope, nullptr,
1169 llvm::make_unique<VarDeclFilterCCC>(*this), CTK_ErrorRecovery)) {
1170 diagnoseTypo(Corrected,
1171 PDiag(Lookup.empty()
1172 ? diag::err_undeclared_var_use_suggest
1173 : diag::err_omp_expected_var_arg_suggest)
1175 VD = Corrected.getCorrectionDeclAs<VarDecl>();
1177 Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
1178 : diag::err_omp_expected_var_arg)
1183 if (!(VD = Lookup.getAsSingle<VarDecl>())) {
1184 Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
1185 Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
1189 Lookup.suppressDiagnostics();
1191 // OpenMP [2.9.2, Syntax, C/C++]
1192 // Variables must be file-scope, namespace-scope, or static block-scope.
1193 if (!VD->hasGlobalStorage()) {
1194 Diag(Id.getLoc(), diag::err_omp_global_var_arg)
1195 << getOpenMPDirectiveName(OMPD_threadprivate) << !VD->isStaticLocal();
1197 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1198 Diag(VD->getLocation(),
1199 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1204 VarDecl *CanonicalVD = VD->getCanonicalDecl();
1205 NamedDecl *ND = cast<NamedDecl>(CanonicalVD);
1206 // OpenMP [2.9.2, Restrictions, C/C++, p.2]
1207 // A threadprivate directive for file-scope variables must appear outside
1208 // any definition or declaration.
1209 if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
1210 !getCurLexicalContext()->isTranslationUnit()) {
1211 Diag(Id.getLoc(), diag::err_omp_var_scope)
1212 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1214 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1215 Diag(VD->getLocation(),
1216 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1220 // OpenMP [2.9.2, Restrictions, C/C++, p.3]
1221 // A threadprivate directive for static class member variables must appear
1222 // in the class definition, in the same scope in which the member
1223 // variables are declared.
1224 if (CanonicalVD->isStaticDataMember() &&
1225 !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
1226 Diag(Id.getLoc(), diag::err_omp_var_scope)
1227 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1229 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1230 Diag(VD->getLocation(),
1231 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1235 // OpenMP [2.9.2, Restrictions, C/C++, p.4]
1236 // A threadprivate directive for namespace-scope variables must appear
1237 // outside any definition or declaration other than the namespace
1238 // definition itself.
1239 if (CanonicalVD->getDeclContext()->isNamespace() &&
1240 (!getCurLexicalContext()->isFileContext() ||
1241 !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
1242 Diag(Id.getLoc(), diag::err_omp_var_scope)
1243 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1245 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1246 Diag(VD->getLocation(),
1247 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1251 // OpenMP [2.9.2, Restrictions, C/C++, p.6]
1252 // A threadprivate directive for static block-scope variables must appear
1253 // in the scope of the variable and not in a nested scope.
1254 if (CanonicalVD->isStaticLocal() && CurScope &&
1255 !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
1256 Diag(Id.getLoc(), diag::err_omp_var_scope)
1257 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1259 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1260 Diag(VD->getLocation(),
1261 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1266 // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
1267 // A threadprivate directive must lexically precede all references to any
1268 // of the variables in its list.
1269 if (VD->isUsed() && !DSAStack->isThreadPrivate(VD)) {
1270 Diag(Id.getLoc(), diag::err_omp_var_used)
1271 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1275 QualType ExprType = VD->getType().getNonReferenceType();
1276 return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
1277 SourceLocation(), VD,
1278 /*RefersToEnclosingVariableOrCapture=*/false,
1279 Id.getLoc(), ExprType, VK_LValue);
1282 Sema::DeclGroupPtrTy
1283 Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
1284 ArrayRef<Expr *> VarList) {
1285 if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
1286 CurContext->addDecl(D);
1287 return DeclGroupPtrTy::make(DeclGroupRef(D));
1293 class LocalVarRefChecker : public ConstStmtVisitor<LocalVarRefChecker, bool> {
1297 bool VisitDeclRefExpr(const DeclRefExpr *E) {
1298 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1299 if (VD->hasLocalStorage()) {
1300 SemaRef.Diag(E->getLocStart(),
1301 diag::err_omp_local_var_in_threadprivate_init)
1302 << E->getSourceRange();
1303 SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
1304 << VD << VD->getSourceRange();
1310 bool VisitStmt(const Stmt *S) {
1311 for (auto Child : S->children()) {
1312 if (Child && Visit(Child))
1317 explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
1321 OMPThreadPrivateDecl *
1322 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
1323 SmallVector<Expr *, 8> Vars;
1324 for (auto &RefExpr : VarList) {
1325 DeclRefExpr *DE = cast<DeclRefExpr>(RefExpr);
1326 VarDecl *VD = cast<VarDecl>(DE->getDecl());
1327 SourceLocation ILoc = DE->getExprLoc();
1329 // Mark variable as used.
1330 VD->setReferenced();
1331 VD->markUsed(Context);
1333 QualType QType = VD->getType();
1334 if (QType->isDependentType() || QType->isInstantiationDependentType()) {
1335 // It will be analyzed later.
1340 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1341 // A threadprivate variable must not have an incomplete type.
1342 if (RequireCompleteType(ILoc, VD->getType(),
1343 diag::err_omp_threadprivate_incomplete_type)) {
1347 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1348 // A threadprivate variable must not have a reference type.
1349 if (VD->getType()->isReferenceType()) {
1350 Diag(ILoc, diag::err_omp_ref_type_arg)
1351 << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
1353 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1354 Diag(VD->getLocation(),
1355 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1360 // Check if this is a TLS variable. If TLS is not being supported, produce
1361 // the corresponding diagnostic.
1362 if ((VD->getTLSKind() != VarDecl::TLS_None &&
1363 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
1364 getLangOpts().OpenMPUseTLS &&
1365 getASTContext().getTargetInfo().isTLSSupported())) ||
1366 (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
1367 !VD->isLocalVarDecl())) {
1368 Diag(ILoc, diag::err_omp_var_thread_local)
1369 << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
1371 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1372 Diag(VD->getLocation(),
1373 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1378 // Check if initial value of threadprivate variable reference variable with
1379 // local storage (it is not supported by runtime).
1380 if (auto Init = VD->getAnyInitializer()) {
1381 LocalVarRefChecker Checker(*this);
1382 if (Checker.Visit(Init))
1386 Vars.push_back(RefExpr);
1387 DSAStack->addDSA(VD, DE, OMPC_threadprivate);
1388 VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
1389 Context, SourceRange(Loc, Loc)));
1390 if (auto *ML = Context.getASTMutationListener())
1391 ML->DeclarationMarkedOpenMPThreadPrivate(VD);
1393 OMPThreadPrivateDecl *D = nullptr;
1394 if (!Vars.empty()) {
1395 D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
1397 D->setAccess(AS_public);
1402 static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack,
1403 const ValueDecl *D, DSAStackTy::DSAVarData DVar,
1404 bool IsLoopIterVar = false) {
1406 SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
1407 << getOpenMPClauseName(DVar.CKind);
1411 PDSA_StaticMemberShared,
1412 PDSA_StaticLocalVarShared,
1413 PDSA_LoopIterVarPrivate,
1414 PDSA_LoopIterVarLinear,
1415 PDSA_LoopIterVarLastprivate,
1416 PDSA_ConstVarShared,
1417 PDSA_GlobalVarShared,
1418 PDSA_TaskVarFirstprivate,
1419 PDSA_LocalVarPrivate,
1421 } Reason = PDSA_Implicit;
1422 bool ReportHint = false;
1423 auto ReportLoc = D->getLocation();
1424 auto *VD = dyn_cast<VarDecl>(D);
1425 if (IsLoopIterVar) {
1426 if (DVar.CKind == OMPC_private)
1427 Reason = PDSA_LoopIterVarPrivate;
1428 else if (DVar.CKind == OMPC_lastprivate)
1429 Reason = PDSA_LoopIterVarLastprivate;
1431 Reason = PDSA_LoopIterVarLinear;
1432 } else if (isOpenMPTaskingDirective(DVar.DKind) &&
1433 DVar.CKind == OMPC_firstprivate) {
1434 Reason = PDSA_TaskVarFirstprivate;
1435 ReportLoc = DVar.ImplicitDSALoc;
1436 } else if (VD && VD->isStaticLocal())
1437 Reason = PDSA_StaticLocalVarShared;
1438 else if (VD && VD->isStaticDataMember())
1439 Reason = PDSA_StaticMemberShared;
1440 else if (VD && VD->isFileVarDecl())
1441 Reason = PDSA_GlobalVarShared;
1442 else if (D->getType().isConstant(SemaRef.getASTContext()))
1443 Reason = PDSA_ConstVarShared;
1444 else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
1446 Reason = PDSA_LocalVarPrivate;
1448 if (Reason != PDSA_Implicit) {
1449 SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
1450 << Reason << ReportHint
1451 << getOpenMPDirectiveName(Stack->getCurrentDirective());
1452 } else if (DVar.ImplicitDSALoc.isValid()) {
1453 SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
1454 << getOpenMPClauseName(DVar.CKind);
1459 class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> {
1464 llvm::SmallVector<Expr *, 8> ImplicitFirstprivate;
1465 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
1468 void VisitDeclRefExpr(DeclRefExpr *E) {
1469 if (E->isTypeDependent() || E->isValueDependent() ||
1470 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1472 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1473 // Skip internally declared variables.
1474 if (VD->isLocalVarDecl() && !CS->capturesVariable(VD))
1477 auto DVar = Stack->getTopDSA(VD, false);
1478 // Check if the variable has explicit DSA set and stop analysis if it so.
1482 auto ELoc = E->getExprLoc();
1483 auto DKind = Stack->getCurrentDirective();
1484 // The default(none) clause requires that each variable that is referenced
1485 // in the construct, and does not have a predetermined data-sharing
1486 // attribute, must have its data-sharing attribute explicitly determined
1487 // by being listed in a data-sharing attribute clause.
1488 if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none &&
1489 isParallelOrTaskRegion(DKind) &&
1490 VarsWithInheritedDSA.count(VD) == 0) {
1491 VarsWithInheritedDSA[VD] = E;
1495 // OpenMP [2.9.3.6, Restrictions, p.2]
1496 // A list item that appears in a reduction clause of the innermost
1497 // enclosing worksharing or parallel construct may not be accessed in an
1499 DVar = Stack->hasInnermostDSA(
1500 VD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1501 [](OpenMPDirectiveKind K) -> bool {
1502 return isOpenMPParallelDirective(K) ||
1503 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
1506 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1508 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1509 ReportOriginalDSA(SemaRef, Stack, VD, DVar);
1513 // Define implicit data-sharing attributes for task.
1514 DVar = Stack->getImplicitDSA(VD, false);
1515 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1516 !Stack->isLoopControlVariable(VD).first)
1517 ImplicitFirstprivate.push_back(E);
1520 void VisitMemberExpr(MemberExpr *E) {
1521 if (E->isTypeDependent() || E->isValueDependent() ||
1522 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1524 if (isa<CXXThisExpr>(E->getBase()->IgnoreParens())) {
1525 if (auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
1526 auto DVar = Stack->getTopDSA(FD, false);
1527 // Check if the variable has explicit DSA set and stop analysis if it
1532 auto ELoc = E->getExprLoc();
1533 auto DKind = Stack->getCurrentDirective();
1534 // OpenMP [2.9.3.6, Restrictions, p.2]
1535 // A list item that appears in a reduction clause of the innermost
1536 // enclosing worksharing or parallel construct may not be accessed in
1537 // an explicit task.
1538 DVar = Stack->hasInnermostDSA(
1539 FD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1540 [](OpenMPDirectiveKind K) -> bool {
1541 return isOpenMPParallelDirective(K) ||
1542 isOpenMPWorksharingDirective(K) ||
1543 isOpenMPTeamsDirective(K);
1546 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1548 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1549 ReportOriginalDSA(SemaRef, Stack, FD, DVar);
1553 // Define implicit data-sharing attributes for task.
1554 DVar = Stack->getImplicitDSA(FD, false);
1555 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1556 !Stack->isLoopControlVariable(FD).first)
1557 ImplicitFirstprivate.push_back(E);
1560 Visit(E->getBase());
1562 void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
1563 for (auto *C : S->clauses()) {
1564 // Skip analysis of arguments of implicitly defined firstprivate clause
1565 // for task directives.
1566 if (C && (!isa<OMPFirstprivateClause>(C) || C->getLocStart().isValid()))
1567 for (auto *CC : C->children()) {
1573 void VisitStmt(Stmt *S) {
1574 for (auto *C : S->children()) {
1575 if (C && !isa<OMPExecutableDirective>(C))
1580 bool isErrorFound() { return ErrorFound; }
1581 ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; }
1582 llvm::DenseMap<ValueDecl *, Expr *> &getVarsWithInheritedDSA() {
1583 return VarsWithInheritedDSA;
1586 DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
1587 : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {}
1591 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
1594 case OMPD_parallel_for:
1595 case OMPD_parallel_for_simd:
1596 case OMPD_parallel_sections:
1598 case OMPD_target_teams: {
1599 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1600 QualType KmpInt32PtrTy =
1601 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1602 Sema::CapturedParamNameType Params[] = {
1603 std::make_pair(".global_tid.", KmpInt32PtrTy),
1604 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1605 std::make_pair(StringRef(), QualType()) // __context with shared vars
1607 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1619 case OMPD_taskgroup:
1620 case OMPD_distribute:
1623 case OMPD_target_data:
1625 case OMPD_target_parallel:
1626 case OMPD_target_parallel_for:
1627 case OMPD_target_parallel_for_simd:
1628 case OMPD_target_simd: {
1629 Sema::CapturedParamNameType Params[] = {
1630 std::make_pair(StringRef(), QualType()) // __context with shared vars
1632 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1637 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1638 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1639 FunctionProtoType::ExtProtoInfo EPI;
1640 EPI.Variadic = true;
1641 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1642 Sema::CapturedParamNameType Params[] = {
1643 std::make_pair(".global_tid.", KmpInt32Ty),
1644 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1645 std::make_pair(".privates.", Context.VoidPtrTy.withConst()),
1646 std::make_pair(".copy_fn.",
1647 Context.getPointerType(CopyFnType).withConst()),
1648 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1649 std::make_pair(StringRef(), QualType()) // __context with shared vars
1651 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1653 // Mark this captured region as inlined, because we don't use outlined
1654 // function directly.
1655 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1656 AlwaysInlineAttr::CreateImplicit(
1657 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1661 case OMPD_taskloop_simd: {
1662 QualType KmpInt32Ty =
1663 Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
1664 QualType KmpUInt64Ty =
1665 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
1666 QualType KmpInt64Ty =
1667 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
1668 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1669 FunctionProtoType::ExtProtoInfo EPI;
1670 EPI.Variadic = true;
1671 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1672 Sema::CapturedParamNameType Params[] = {
1673 std::make_pair(".global_tid.", KmpInt32Ty),
1674 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1675 std::make_pair(".privates.",
1676 Context.VoidPtrTy.withConst().withRestrict()),
1679 Context.getPointerType(CopyFnType).withConst().withRestrict()),
1680 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1681 std::make_pair(".lb.", KmpUInt64Ty),
1682 std::make_pair(".ub.", KmpUInt64Ty), std::make_pair(".st.", KmpInt64Ty),
1683 std::make_pair(".liter.", KmpInt32Ty),
1684 std::make_pair(StringRef(), QualType()) // __context with shared vars
1686 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1688 // Mark this captured region as inlined, because we don't use outlined
1689 // function directly.
1690 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1691 AlwaysInlineAttr::CreateImplicit(
1692 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1695 case OMPD_distribute_parallel_for_simd:
1696 case OMPD_distribute_simd:
1697 case OMPD_distribute_parallel_for:
1698 case OMPD_teams_distribute:
1699 case OMPD_teams_distribute_simd:
1700 case OMPD_teams_distribute_parallel_for_simd:
1701 case OMPD_teams_distribute_parallel_for:
1702 case OMPD_target_teams_distribute:
1703 case OMPD_target_teams_distribute_parallel_for:
1704 case OMPD_target_teams_distribute_parallel_for_simd:
1705 case OMPD_target_teams_distribute_simd: {
1706 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1707 QualType KmpInt32PtrTy =
1708 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1709 Sema::CapturedParamNameType Params[] = {
1710 std::make_pair(".global_tid.", KmpInt32PtrTy),
1711 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1712 std::make_pair(".previous.lb.", Context.getSizeType()),
1713 std::make_pair(".previous.ub.", Context.getSizeType()),
1714 std::make_pair(StringRef(), QualType()) // __context with shared vars
1716 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1720 case OMPD_threadprivate:
1721 case OMPD_taskyield:
1724 case OMPD_cancellation_point:
1727 case OMPD_target_enter_data:
1728 case OMPD_target_exit_data:
1729 case OMPD_declare_reduction:
1730 case OMPD_declare_simd:
1731 case OMPD_declare_target:
1732 case OMPD_end_declare_target:
1733 case OMPD_target_update:
1734 llvm_unreachable("OpenMP Directive is not allowed");
1736 llvm_unreachable("Unknown OpenMP directive");
1740 static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id,
1741 Expr *CaptureExpr, bool WithInit,
1742 bool AsExpression) {
1743 assert(CaptureExpr);
1744 ASTContext &C = S.getASTContext();
1745 Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
1746 QualType Ty = Init->getType();
1747 if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) {
1748 if (S.getLangOpts().CPlusPlus)
1749 Ty = C.getLValueReferenceType(Ty);
1751 Ty = C.getPointerType(Ty);
1753 S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init);
1754 if (!Res.isUsable())
1760 auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty,
1761 CaptureExpr->getLocStart());
1763 CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C, SourceRange()));
1764 S.CurContext->addHiddenDecl(CED);
1765 S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false);
1769 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
1771 OMPCapturedExprDecl *CD;
1772 if (auto *VD = S.IsOpenMPCapturedDecl(D))
1773 CD = cast<OMPCapturedExprDecl>(VD);
1775 CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit,
1776 /*AsExpression=*/false);
1777 return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1778 CaptureExpr->getExprLoc());
1781 static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) {
1784 buildCaptureDecl(S, &S.getASTContext().Idents.get(".capture_expr."),
1785 CaptureExpr, /*WithInit=*/true, /*AsExpression=*/true);
1786 Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1787 CaptureExpr->getExprLoc());
1789 ExprResult Res = Ref;
1790 if (!S.getLangOpts().CPlusPlus &&
1791 CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() &&
1792 Ref->getType()->isPointerType())
1793 Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref);
1794 if (!Res.isUsable())
1796 return CaptureExpr->isGLValue() ? Res : S.DefaultLvalueConversion(Res.get());
1799 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
1800 ArrayRef<OMPClause *> Clauses) {
1801 if (!S.isUsable()) {
1802 ActOnCapturedRegionError();
1806 OMPOrderedClause *OC = nullptr;
1807 OMPScheduleClause *SC = nullptr;
1808 SmallVector<OMPLinearClause *, 4> LCs;
1809 // This is required for proper codegen.
1810 for (auto *Clause : Clauses) {
1811 if (isOpenMPPrivate(Clause->getClauseKind()) ||
1812 Clause->getClauseKind() == OMPC_copyprivate ||
1813 (getLangOpts().OpenMPUseTLS &&
1814 getASTContext().getTargetInfo().isTLSSupported() &&
1815 Clause->getClauseKind() == OMPC_copyin)) {
1816 DSAStack->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin);
1817 // Mark all variables in private list clauses as used in inner region.
1818 for (auto *VarRef : Clause->children()) {
1819 if (auto *E = cast_or_null<Expr>(VarRef)) {
1820 MarkDeclarationsReferencedInExpr(E);
1823 DSAStack->setForceVarCapturing(/*V=*/false);
1824 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective())) {
1825 // Mark all variables in private list clauses as used in inner region.
1826 // Required for proper codegen of combined directives.
1827 // TODO: add processing for other clauses.
1828 if (auto *C = OMPClauseWithPreInit::get(Clause)) {
1829 if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
1830 for (auto *D : DS->decls())
1831 MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
1834 if (auto *C = OMPClauseWithPostUpdate::get(Clause)) {
1835 if (auto *E = C->getPostUpdateExpr())
1836 MarkDeclarationsReferencedInExpr(E);
1839 if (Clause->getClauseKind() == OMPC_schedule)
1840 SC = cast<OMPScheduleClause>(Clause);
1841 else if (Clause->getClauseKind() == OMPC_ordered)
1842 OC = cast<OMPOrderedClause>(Clause);
1843 else if (Clause->getClauseKind() == OMPC_linear)
1844 LCs.push_back(cast<OMPLinearClause>(Clause));
1846 bool ErrorFound = false;
1847 // OpenMP, 2.7.1 Loop Construct, Restrictions
1848 // The nonmonotonic modifier cannot be specified if an ordered clause is
1851 (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
1852 SC->getSecondScheduleModifier() ==
1853 OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
1855 Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
1856 ? SC->getFirstScheduleModifierLoc()
1857 : SC->getSecondScheduleModifierLoc(),
1858 diag::err_omp_schedule_nonmonotonic_ordered)
1859 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1862 if (!LCs.empty() && OC && OC->getNumForLoops()) {
1863 for (auto *C : LCs) {
1864 Diag(C->getLocStart(), diag::err_omp_linear_ordered)
1865 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1869 if (isOpenMPWorksharingDirective(DSAStack->getCurrentDirective()) &&
1870 isOpenMPSimdDirective(DSAStack->getCurrentDirective()) && OC &&
1871 OC->getNumForLoops()) {
1872 Diag(OC->getLocStart(), diag::err_omp_ordered_simd)
1873 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
1877 ActOnCapturedRegionError();
1880 return ActOnCapturedRegionEnd(S.get());
1883 static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack,
1884 OpenMPDirectiveKind CurrentRegion,
1885 const DeclarationNameInfo &CurrentName,
1886 OpenMPDirectiveKind CancelRegion,
1887 SourceLocation StartLoc) {
1888 if (Stack->getCurScope()) {
1889 auto ParentRegion = Stack->getParentDirective();
1890 auto OffendingRegion = ParentRegion;
1891 bool NestingProhibited = false;
1892 bool CloseNesting = true;
1893 bool OrphanSeen = false;
1896 ShouldBeInParallelRegion,
1897 ShouldBeInOrderedRegion,
1898 ShouldBeInTargetRegion,
1899 ShouldBeInTeamsRegion
1900 } Recommend = NoRecommend;
1901 if (isOpenMPSimdDirective(ParentRegion) && CurrentRegion != OMPD_ordered) {
1902 // OpenMP [2.16, Nesting of Regions]
1903 // OpenMP constructs may not be nested inside a simd region.
1904 // OpenMP [2.8.1,simd Construct, Restrictions]
1905 // An ordered construct with the simd clause is the only OpenMP
1906 // construct that can appear in the simd region.
1907 // Allowing a SIMD construct nested in another SIMD construct is an
1908 // extension. The OpenMP 4.5 spec does not allow it. Issue a warning
1910 SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd)
1911 ? diag::err_omp_prohibited_region_simd
1912 : diag::warn_omp_nesting_simd);
1913 return CurrentRegion != OMPD_simd;
1915 if (ParentRegion == OMPD_atomic) {
1916 // OpenMP [2.16, Nesting of Regions]
1917 // OpenMP constructs may not be nested inside an atomic region.
1918 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic);
1921 if (CurrentRegion == OMPD_section) {
1922 // OpenMP [2.7.2, sections Construct, Restrictions]
1923 // Orphaned section directives are prohibited. That is, the section
1924 // directives must appear within the sections construct and must not be
1925 // encountered elsewhere in the sections region.
1926 if (ParentRegion != OMPD_sections &&
1927 ParentRegion != OMPD_parallel_sections) {
1928 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
1929 << (ParentRegion != OMPD_unknown)
1930 << getOpenMPDirectiveName(ParentRegion);
1935 // Allow some constructs (except teams) to be orphaned (they could be
1936 // used in functions, called from OpenMP regions with the required
1938 if (ParentRegion == OMPD_unknown &&
1939 !isOpenMPNestingTeamsDirective(CurrentRegion))
1941 if (CurrentRegion == OMPD_cancellation_point ||
1942 CurrentRegion == OMPD_cancel) {
1943 // OpenMP [2.16, Nesting of Regions]
1944 // A cancellation point construct for which construct-type-clause is
1945 // taskgroup must be nested inside a task construct. A cancellation
1946 // point construct for which construct-type-clause is not taskgroup must
1947 // be closely nested inside an OpenMP construct that matches the type
1948 // specified in construct-type-clause.
1949 // A cancel construct for which construct-type-clause is taskgroup must be
1950 // nested inside a task construct. A cancel construct for which
1951 // construct-type-clause is not taskgroup must be closely nested inside an
1952 // OpenMP construct that matches the type specified in
1953 // construct-type-clause.
1955 !((CancelRegion == OMPD_parallel &&
1956 (ParentRegion == OMPD_parallel ||
1957 ParentRegion == OMPD_target_parallel)) ||
1958 (CancelRegion == OMPD_for &&
1959 (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for ||
1960 ParentRegion == OMPD_target_parallel_for)) ||
1961 (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) ||
1962 (CancelRegion == OMPD_sections &&
1963 (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
1964 ParentRegion == OMPD_parallel_sections)));
1965 } else if (CurrentRegion == OMPD_master) {
1966 // OpenMP [2.16, Nesting of Regions]
1967 // A master region may not be closely nested inside a worksharing,
1968 // atomic, or explicit task region.
1969 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
1970 isOpenMPTaskingDirective(ParentRegion);
1971 } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
1972 // OpenMP [2.16, Nesting of Regions]
1973 // A critical region may not be nested (closely or otherwise) inside a
1974 // critical region with the same name. Note that this restriction is not
1975 // sufficient to prevent deadlock.
1976 SourceLocation PreviousCriticalLoc;
1977 bool DeadLock = Stack->hasDirective(
1978 [CurrentName, &PreviousCriticalLoc](OpenMPDirectiveKind K,
1979 const DeclarationNameInfo &DNI,
1980 SourceLocation Loc) -> bool {
1981 if (K == OMPD_critical && DNI.getName() == CurrentName.getName()) {
1982 PreviousCriticalLoc = Loc;
1987 false /* skip top directive */);
1989 SemaRef.Diag(StartLoc,
1990 diag::err_omp_prohibited_region_critical_same_name)
1991 << CurrentName.getName();
1992 if (PreviousCriticalLoc.isValid())
1993 SemaRef.Diag(PreviousCriticalLoc,
1994 diag::note_omp_previous_critical_region);
1997 } else if (CurrentRegion == OMPD_barrier) {
1998 // OpenMP [2.16, Nesting of Regions]
1999 // A barrier region may not be closely nested inside a worksharing,
2000 // explicit task, critical, ordered, atomic, or master region.
2001 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2002 isOpenMPTaskingDirective(ParentRegion) ||
2003 ParentRegion == OMPD_master ||
2004 ParentRegion == OMPD_critical ||
2005 ParentRegion == OMPD_ordered;
2006 } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
2007 !isOpenMPParallelDirective(CurrentRegion) &&
2008 !isOpenMPTeamsDirective(CurrentRegion)) {
2009 // OpenMP [2.16, Nesting of Regions]
2010 // A worksharing region may not be closely nested inside a worksharing,
2011 // explicit task, critical, ordered, atomic, or master region.
2012 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2013 isOpenMPTaskingDirective(ParentRegion) ||
2014 ParentRegion == OMPD_master ||
2015 ParentRegion == OMPD_critical ||
2016 ParentRegion == OMPD_ordered;
2017 Recommend = ShouldBeInParallelRegion;
2018 } else if (CurrentRegion == OMPD_ordered) {
2019 // OpenMP [2.16, Nesting of Regions]
2020 // An ordered region may not be closely nested inside a critical,
2021 // atomic, or explicit task region.
2022 // An ordered region must be closely nested inside a loop region (or
2023 // parallel loop region) with an ordered clause.
2024 // OpenMP [2.8.1,simd Construct, Restrictions]
2025 // An ordered construct with the simd clause is the only OpenMP construct
2026 // that can appear in the simd region.
2027 NestingProhibited = ParentRegion == OMPD_critical ||
2028 isOpenMPTaskingDirective(ParentRegion) ||
2029 !(isOpenMPSimdDirective(ParentRegion) ||
2030 Stack->isParentOrderedRegion());
2031 Recommend = ShouldBeInOrderedRegion;
2032 } else if (isOpenMPNestingTeamsDirective(CurrentRegion)) {
2033 // OpenMP [2.16, Nesting of Regions]
2034 // If specified, a teams construct must be contained within a target
2036 NestingProhibited = ParentRegion != OMPD_target;
2037 OrphanSeen = ParentRegion == OMPD_unknown;
2038 Recommend = ShouldBeInTargetRegion;
2039 Stack->setParentTeamsRegionLoc(Stack->getConstructLoc());
2041 if (!NestingProhibited &&
2042 !isOpenMPTargetExecutionDirective(CurrentRegion) &&
2043 !isOpenMPTargetDataManagementDirective(CurrentRegion) &&
2044 (ParentRegion == OMPD_teams || ParentRegion == OMPD_target_teams)) {
2045 // OpenMP [2.16, Nesting of Regions]
2046 // distribute, parallel, parallel sections, parallel workshare, and the
2047 // parallel loop and parallel loop SIMD constructs are the only OpenMP
2048 // constructs that can be closely nested in the teams region.
2049 NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) &&
2050 !isOpenMPDistributeDirective(CurrentRegion);
2051 Recommend = ShouldBeInParallelRegion;
2053 if (!NestingProhibited &&
2054 isOpenMPNestingDistributeDirective(CurrentRegion)) {
2055 // OpenMP 4.5 [2.17 Nesting of Regions]
2056 // The region associated with the distribute construct must be strictly
2057 // nested inside a teams region
2059 (ParentRegion != OMPD_teams && ParentRegion != OMPD_target_teams);
2060 Recommend = ShouldBeInTeamsRegion;
2062 if (!NestingProhibited &&
2063 (isOpenMPTargetExecutionDirective(CurrentRegion) ||
2064 isOpenMPTargetDataManagementDirective(CurrentRegion))) {
2065 // OpenMP 4.5 [2.17 Nesting of Regions]
2066 // If a target, target update, target data, target enter data, or
2067 // target exit data construct is encountered during execution of a
2068 // target region, the behavior is unspecified.
2069 NestingProhibited = Stack->hasDirective(
2070 [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &,
2071 SourceLocation) -> bool {
2072 if (isOpenMPTargetExecutionDirective(K)) {
2073 OffendingRegion = K;
2078 false /* don't skip top directive */);
2079 CloseNesting = false;
2081 if (NestingProhibited) {
2083 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_device_directive)
2084 << getOpenMPDirectiveName(CurrentRegion) << Recommend;
2086 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region)
2087 << CloseNesting << getOpenMPDirectiveName(OffendingRegion)
2088 << Recommend << getOpenMPDirectiveName(CurrentRegion);
2096 static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
2097 ArrayRef<OMPClause *> Clauses,
2098 ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
2099 bool ErrorFound = false;
2100 unsigned NamedModifiersNumber = 0;
2101 SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers(
2103 SmallVector<SourceLocation, 4> NameModifierLoc;
2104 for (const auto *C : Clauses) {
2105 if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {
2106 // At most one if clause without a directive-name-modifier can appear on
2108 OpenMPDirectiveKind CurNM = IC->getNameModifier();
2109 if (FoundNameModifiers[CurNM]) {
2110 S.Diag(C->getLocStart(), diag::err_omp_more_one_clause)
2111 << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if)
2112 << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM);
2114 } else if (CurNM != OMPD_unknown) {
2115 NameModifierLoc.push_back(IC->getNameModifierLoc());
2116 ++NamedModifiersNumber;
2118 FoundNameModifiers[CurNM] = IC;
2119 if (CurNM == OMPD_unknown)
2121 // Check if the specified name modifier is allowed for the current
2123 // At most one if clause with the particular directive-name-modifier can
2124 // appear on the directive.
2125 bool MatchFound = false;
2126 for (auto NM : AllowedNameModifiers) {
2133 S.Diag(IC->getNameModifierLoc(),
2134 diag::err_omp_wrong_if_directive_name_modifier)
2135 << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind);
2140 // If any if clause on the directive includes a directive-name-modifier then
2141 // all if clauses on the directive must include a directive-name-modifier.
2142 if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {
2143 if (NamedModifiersNumber == AllowedNameModifiers.size()) {
2144 S.Diag(FoundNameModifiers[OMPD_unknown]->getLocStart(),
2145 diag::err_omp_no_more_if_clause);
2148 std::string Sep(", ");
2149 unsigned AllowedCnt = 0;
2150 unsigned TotalAllowedNum =
2151 AllowedNameModifiers.size() - NamedModifiersNumber;
2152 for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End;
2154 OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt];
2155 if (!FoundNameModifiers[NM]) {
2157 Values += getOpenMPDirectiveName(NM);
2159 if (AllowedCnt + 2 == TotalAllowedNum)
2161 else if (AllowedCnt + 1 != TotalAllowedNum)
2166 S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getLocStart(),
2167 diag::err_omp_unnamed_if_clause)
2168 << (TotalAllowedNum > 1) << Values;
2170 for (auto Loc : NameModifierLoc) {
2171 S.Diag(Loc, diag::note_omp_previous_named_if_clause);
2178 StmtResult Sema::ActOnOpenMPExecutableDirective(
2179 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
2180 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
2181 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
2182 StmtResult Res = StmtError();
2183 if (CheckNestingOfRegions(*this, DSAStack, Kind, DirName, CancelRegion,
2187 llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
2188 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
2189 bool ErrorFound = false;
2190 ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
2192 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
2194 // Check default data sharing attributes for referenced variables.
2195 DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt));
2196 DSAChecker.Visit(cast<CapturedStmt>(AStmt)->getCapturedStmt());
2197 if (DSAChecker.isErrorFound())
2199 // Generate list of implicitly defined firstprivate variables.
2200 VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA();
2202 if (!DSAChecker.getImplicitFirstprivate().empty()) {
2203 if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause(
2204 DSAChecker.getImplicitFirstprivate(), SourceLocation(),
2205 SourceLocation(), SourceLocation())) {
2206 ClausesWithImplicit.push_back(Implicit);
2207 ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() !=
2208 DSAChecker.getImplicitFirstprivate().size();
2214 llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
2217 Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
2219 AllowedNameModifiers.push_back(OMPD_parallel);
2222 Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
2223 VarsWithInheritedDSA);
2226 Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
2227 VarsWithInheritedDSA);
2230 Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2231 EndLoc, VarsWithInheritedDSA);
2234 Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
2238 assert(ClausesWithImplicit.empty() &&
2239 "No clauses are allowed for 'omp section' directive");
2240 Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
2243 Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
2247 assert(ClausesWithImplicit.empty() &&
2248 "No clauses are allowed for 'omp master' directive");
2249 Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
2252 Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt,
2255 case OMPD_parallel_for:
2256 Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc,
2257 EndLoc, VarsWithInheritedDSA);
2258 AllowedNameModifiers.push_back(OMPD_parallel);
2260 case OMPD_parallel_for_simd:
2261 Res = ActOnOpenMPParallelForSimdDirective(
2262 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2263 AllowedNameModifiers.push_back(OMPD_parallel);
2265 case OMPD_parallel_sections:
2266 Res = ActOnOpenMPParallelSectionsDirective(ClausesWithImplicit, AStmt,
2268 AllowedNameModifiers.push_back(OMPD_parallel);
2272 ActOnOpenMPTaskDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
2273 AllowedNameModifiers.push_back(OMPD_task);
2275 case OMPD_taskyield:
2276 assert(ClausesWithImplicit.empty() &&
2277 "No clauses are allowed for 'omp taskyield' directive");
2278 assert(AStmt == nullptr &&
2279 "No associated statement allowed for 'omp taskyield' directive");
2280 Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc);
2283 assert(ClausesWithImplicit.empty() &&
2284 "No clauses are allowed for 'omp barrier' directive");
2285 assert(AStmt == nullptr &&
2286 "No associated statement allowed for 'omp barrier' directive");
2287 Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
2290 assert(ClausesWithImplicit.empty() &&
2291 "No clauses are allowed for 'omp taskwait' directive");
2292 assert(AStmt == nullptr &&
2293 "No associated statement allowed for 'omp taskwait' directive");
2294 Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc);
2296 case OMPD_taskgroup:
2297 assert(ClausesWithImplicit.empty() &&
2298 "No clauses are allowed for 'omp taskgroup' directive");
2299 Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc);
2302 assert(AStmt == nullptr &&
2303 "No associated statement allowed for 'omp flush' directive");
2304 Res = ActOnOpenMPFlushDirective(ClausesWithImplicit, StartLoc, EndLoc);
2307 Res = ActOnOpenMPOrderedDirective(ClausesWithImplicit, AStmt, StartLoc,
2311 Res = ActOnOpenMPAtomicDirective(ClausesWithImplicit, AStmt, StartLoc,
2316 ActOnOpenMPTeamsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
2319 Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc,
2321 AllowedNameModifiers.push_back(OMPD_target);
2323 case OMPD_target_parallel:
2324 Res = ActOnOpenMPTargetParallelDirective(ClausesWithImplicit, AStmt,
2326 AllowedNameModifiers.push_back(OMPD_target);
2327 AllowedNameModifiers.push_back(OMPD_parallel);
2329 case OMPD_target_parallel_for:
2330 Res = ActOnOpenMPTargetParallelForDirective(
2331 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2332 AllowedNameModifiers.push_back(OMPD_target);
2333 AllowedNameModifiers.push_back(OMPD_parallel);
2335 case OMPD_cancellation_point:
2336 assert(ClausesWithImplicit.empty() &&
2337 "No clauses are allowed for 'omp cancellation point' directive");
2338 assert(AStmt == nullptr && "No associated statement allowed for 'omp "
2339 "cancellation point' directive");
2340 Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion);
2343 assert(AStmt == nullptr &&
2344 "No associated statement allowed for 'omp cancel' directive");
2345 Res = ActOnOpenMPCancelDirective(ClausesWithImplicit, StartLoc, EndLoc,
2347 AllowedNameModifiers.push_back(OMPD_cancel);
2349 case OMPD_target_data:
2350 Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc,
2352 AllowedNameModifiers.push_back(OMPD_target_data);
2354 case OMPD_target_enter_data:
2355 Res = ActOnOpenMPTargetEnterDataDirective(ClausesWithImplicit, StartLoc,
2357 AllowedNameModifiers.push_back(OMPD_target_enter_data);
2359 case OMPD_target_exit_data:
2360 Res = ActOnOpenMPTargetExitDataDirective(ClausesWithImplicit, StartLoc,
2362 AllowedNameModifiers.push_back(OMPD_target_exit_data);
2365 Res = ActOnOpenMPTaskLoopDirective(ClausesWithImplicit, AStmt, StartLoc,
2366 EndLoc, VarsWithInheritedDSA);
2367 AllowedNameModifiers.push_back(OMPD_taskloop);
2369 case OMPD_taskloop_simd:
2370 Res = ActOnOpenMPTaskLoopSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2371 EndLoc, VarsWithInheritedDSA);
2372 AllowedNameModifiers.push_back(OMPD_taskloop);
2374 case OMPD_distribute:
2375 Res = ActOnOpenMPDistributeDirective(ClausesWithImplicit, AStmt, StartLoc,
2376 EndLoc, VarsWithInheritedDSA);
2378 case OMPD_target_update:
2379 assert(!AStmt && "Statement is not allowed for target update");
2381 ActOnOpenMPTargetUpdateDirective(ClausesWithImplicit, StartLoc, EndLoc);
2382 AllowedNameModifiers.push_back(OMPD_target_update);
2384 case OMPD_distribute_parallel_for:
2385 Res = ActOnOpenMPDistributeParallelForDirective(
2386 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2387 AllowedNameModifiers.push_back(OMPD_parallel);
2389 case OMPD_distribute_parallel_for_simd:
2390 Res = ActOnOpenMPDistributeParallelForSimdDirective(
2391 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2392 AllowedNameModifiers.push_back(OMPD_parallel);
2394 case OMPD_distribute_simd:
2395 Res = ActOnOpenMPDistributeSimdDirective(
2396 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2398 case OMPD_target_parallel_for_simd:
2399 Res = ActOnOpenMPTargetParallelForSimdDirective(
2400 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2401 AllowedNameModifiers.push_back(OMPD_target);
2402 AllowedNameModifiers.push_back(OMPD_parallel);
2404 case OMPD_target_simd:
2405 Res = ActOnOpenMPTargetSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2406 EndLoc, VarsWithInheritedDSA);
2407 AllowedNameModifiers.push_back(OMPD_target);
2409 case OMPD_teams_distribute:
2410 Res = ActOnOpenMPTeamsDistributeDirective(
2411 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2413 case OMPD_teams_distribute_simd:
2414 Res = ActOnOpenMPTeamsDistributeSimdDirective(
2415 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2417 case OMPD_teams_distribute_parallel_for_simd:
2418 Res = ActOnOpenMPTeamsDistributeParallelForSimdDirective(
2419 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2420 AllowedNameModifiers.push_back(OMPD_parallel);
2422 case OMPD_teams_distribute_parallel_for:
2423 Res = ActOnOpenMPTeamsDistributeParallelForDirective(
2424 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2425 AllowedNameModifiers.push_back(OMPD_parallel);
2427 case OMPD_target_teams:
2428 Res = ActOnOpenMPTargetTeamsDirective(ClausesWithImplicit, AStmt, StartLoc,
2430 AllowedNameModifiers.push_back(OMPD_target);
2432 case OMPD_target_teams_distribute:
2433 Res = ActOnOpenMPTargetTeamsDistributeDirective(
2434 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2435 AllowedNameModifiers.push_back(OMPD_target);
2437 case OMPD_target_teams_distribute_parallel_for:
2438 Res = ActOnOpenMPTargetTeamsDistributeParallelForDirective(
2439 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2440 AllowedNameModifiers.push_back(OMPD_target);
2441 AllowedNameModifiers.push_back(OMPD_parallel);
2443 case OMPD_target_teams_distribute_parallel_for_simd:
2444 Res = ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
2445 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2446 AllowedNameModifiers.push_back(OMPD_target);
2447 AllowedNameModifiers.push_back(OMPD_parallel);
2449 case OMPD_target_teams_distribute_simd:
2450 Res = ActOnOpenMPTargetTeamsDistributeSimdDirective(
2451 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2452 AllowedNameModifiers.push_back(OMPD_target);
2454 case OMPD_declare_target:
2455 case OMPD_end_declare_target:
2456 case OMPD_threadprivate:
2457 case OMPD_declare_reduction:
2458 case OMPD_declare_simd:
2459 llvm_unreachable("OpenMP Directive is not allowed");
2461 llvm_unreachable("Unknown OpenMP directive");
2464 for (auto P : VarsWithInheritedDSA) {
2465 Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
2466 << P.first << P.second->getSourceRange();
2468 ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound;
2470 if (!AllowedNameModifiers.empty())
2471 ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) ||
2479 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
2480 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
2481 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
2482 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
2483 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
2484 assert(Aligneds.size() == Alignments.size());
2485 assert(Linears.size() == LinModifiers.size());
2486 assert(Linears.size() == Steps.size());
2487 if (!DG || DG.get().isNull())
2488 return DeclGroupPtrTy();
2490 if (!DG.get().isSingleDecl()) {
2491 Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd);
2494 auto *ADecl = DG.get().getSingleDecl();
2495 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
2496 ADecl = FTD->getTemplatedDecl();
2498 auto *FD = dyn_cast<FunctionDecl>(ADecl);
2500 Diag(ADecl->getLocation(), diag::err_omp_function_expected);
2501 return DeclGroupPtrTy();
2504 // OpenMP [2.8.2, declare simd construct, Description]
2505 // The parameter of the simdlen clause must be a constant positive integer
2509 SL = VerifyPositiveIntegerConstantInClause(Simdlen, OMPC_simdlen);
2510 // OpenMP [2.8.2, declare simd construct, Description]
2511 // The special this pointer can be used as if was one of the arguments to the
2512 // function in any of the linear, aligned, or uniform clauses.
2513 // The uniform clause declares one or more arguments to have an invariant
2514 // value for all concurrent invocations of the function in the execution of a
2515 // single SIMD loop.
2516 llvm::DenseMap<Decl *, Expr *> UniformedArgs;
2517 Expr *UniformedLinearThis = nullptr;
2518 for (auto *E : Uniforms) {
2519 E = E->IgnoreParenImpCasts();
2520 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2521 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
2522 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2523 FD->getParamDecl(PVD->getFunctionScopeIndex())
2524 ->getCanonicalDecl() == PVD->getCanonicalDecl()) {
2525 UniformedArgs.insert(std::make_pair(PVD->getCanonicalDecl(), E));
2528 if (isa<CXXThisExpr>(E)) {
2529 UniformedLinearThis = E;
2532 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2533 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2535 // OpenMP [2.8.2, declare simd construct, Description]
2536 // The aligned clause declares that the object to which each list item points
2537 // is aligned to the number of bytes expressed in the optional parameter of
2538 // the aligned clause.
2539 // The special this pointer can be used as if was one of the arguments to the
2540 // function in any of the linear, aligned, or uniform clauses.
2541 // The type of list items appearing in the aligned clause must be array,
2542 // pointer, reference to array, or reference to pointer.
2543 llvm::DenseMap<Decl *, Expr *> AlignedArgs;
2544 Expr *AlignedThis = nullptr;
2545 for (auto *E : Aligneds) {
2546 E = E->IgnoreParenImpCasts();
2547 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2548 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2549 auto *CanonPVD = PVD->getCanonicalDecl();
2550 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2551 FD->getParamDecl(PVD->getFunctionScopeIndex())
2552 ->getCanonicalDecl() == CanonPVD) {
2553 // OpenMP [2.8.1, simd construct, Restrictions]
2554 // A list-item cannot appear in more than one aligned clause.
2555 if (AlignedArgs.count(CanonPVD) > 0) {
2556 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
2557 << 1 << E->getSourceRange();
2558 Diag(AlignedArgs[CanonPVD]->getExprLoc(),
2559 diag::note_omp_explicit_dsa)
2560 << getOpenMPClauseName(OMPC_aligned);
2563 AlignedArgs[CanonPVD] = E;
2564 QualType QTy = PVD->getType()
2565 .getNonReferenceType()
2566 .getUnqualifiedType()
2567 .getCanonicalType();
2568 const Type *Ty = QTy.getTypePtrOrNull();
2569 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
2570 Diag(E->getExprLoc(), diag::err_omp_aligned_expected_array_or_ptr)
2571 << QTy << getLangOpts().CPlusPlus << E->getSourceRange();
2572 Diag(PVD->getLocation(), diag::note_previous_decl) << PVD;
2577 if (isa<CXXThisExpr>(E)) {
2579 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
2580 << 2 << E->getSourceRange();
2581 Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa)
2582 << getOpenMPClauseName(OMPC_aligned);
2587 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2588 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2590 // The optional parameter of the aligned clause, alignment, must be a constant
2591 // positive integer expression. If no optional parameter is specified,
2592 // implementation-defined default alignments for SIMD instructions on the
2593 // target platforms are assumed.
2594 SmallVector<Expr *, 4> NewAligns;
2595 for (auto *E : Alignments) {
2598 Align = VerifyPositiveIntegerConstantInClause(E, OMPC_aligned);
2599 NewAligns.push_back(Align.get());
2601 // OpenMP [2.8.2, declare simd construct, Description]
2602 // The linear clause declares one or more list items to be private to a SIMD
2603 // lane and to have a linear relationship with respect to the iteration space
2605 // The special this pointer can be used as if was one of the arguments to the
2606 // function in any of the linear, aligned, or uniform clauses.
2607 // When a linear-step expression is specified in a linear clause it must be
2608 // either a constant integer expression or an integer-typed parameter that is
2609 // specified in a uniform clause on the directive.
2610 llvm::DenseMap<Decl *, Expr *> LinearArgs;
2611 const bool IsUniformedThis = UniformedLinearThis != nullptr;
2612 auto MI = LinModifiers.begin();
2613 for (auto *E : Linears) {
2614 auto LinKind = static_cast<OpenMPLinearClauseKind>(*MI);
2616 E = E->IgnoreParenImpCasts();
2617 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2618 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2619 auto *CanonPVD = PVD->getCanonicalDecl();
2620 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2621 FD->getParamDecl(PVD->getFunctionScopeIndex())
2622 ->getCanonicalDecl() == CanonPVD) {
2623 // OpenMP [2.15.3.7, linear Clause, Restrictions]
2624 // A list-item cannot appear in more than one linear clause.
2625 if (LinearArgs.count(CanonPVD) > 0) {
2626 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2627 << getOpenMPClauseName(OMPC_linear)
2628 << getOpenMPClauseName(OMPC_linear) << E->getSourceRange();
2629 Diag(LinearArgs[CanonPVD]->getExprLoc(),
2630 diag::note_omp_explicit_dsa)
2631 << getOpenMPClauseName(OMPC_linear);
2634 // Each argument can appear in at most one uniform or linear clause.
2635 if (UniformedArgs.count(CanonPVD) > 0) {
2636 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2637 << getOpenMPClauseName(OMPC_linear)
2638 << getOpenMPClauseName(OMPC_uniform) << E->getSourceRange();
2639 Diag(UniformedArgs[CanonPVD]->getExprLoc(),
2640 diag::note_omp_explicit_dsa)
2641 << getOpenMPClauseName(OMPC_uniform);
2644 LinearArgs[CanonPVD] = E;
2645 if (E->isValueDependent() || E->isTypeDependent() ||
2646 E->isInstantiationDependent() ||
2647 E->containsUnexpandedParameterPack())
2649 (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind,
2650 PVD->getOriginalType());
2654 if (isa<CXXThisExpr>(E)) {
2655 if (UniformedLinearThis) {
2656 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2657 << getOpenMPClauseName(OMPC_linear)
2658 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear)
2659 << E->getSourceRange();
2660 Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa)
2661 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform
2665 UniformedLinearThis = E;
2666 if (E->isValueDependent() || E->isTypeDependent() ||
2667 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
2669 (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind,
2673 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2674 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2676 Expr *Step = nullptr;
2677 Expr *NewStep = nullptr;
2678 SmallVector<Expr *, 4> NewSteps;
2679 for (auto *E : Steps) {
2680 // Skip the same step expression, it was checked already.
2681 if (Step == E || !E) {
2682 NewSteps.push_back(E ? NewStep : nullptr);
2686 if (auto *DRE = dyn_cast<DeclRefExpr>(Step))
2687 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2688 auto *CanonPVD = PVD->getCanonicalDecl();
2689 if (UniformedArgs.count(CanonPVD) == 0) {
2690 Diag(Step->getExprLoc(), diag::err_omp_expected_uniform_param)
2691 << Step->getSourceRange();
2692 } else if (E->isValueDependent() || E->isTypeDependent() ||
2693 E->isInstantiationDependent() ||
2694 E->containsUnexpandedParameterPack() ||
2695 CanonPVD->getType()->hasIntegerRepresentation())
2696 NewSteps.push_back(Step);
2698 Diag(Step->getExprLoc(), diag::err_omp_expected_int_param)
2699 << Step->getSourceRange();
2704 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
2705 !Step->isInstantiationDependent() &&
2706 !Step->containsUnexpandedParameterPack()) {
2707 NewStep = PerformOpenMPImplicitIntegerConversion(Step->getExprLoc(), Step)
2710 NewStep = VerifyIntegerConstantExpression(NewStep).get();
2712 NewSteps.push_back(NewStep);
2714 auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
2715 Context, BS, SL.get(), const_cast<Expr **>(Uniforms.data()),
2716 Uniforms.size(), const_cast<Expr **>(Aligneds.data()), Aligneds.size(),
2717 const_cast<Expr **>(NewAligns.data()), NewAligns.size(),
2718 const_cast<Expr **>(Linears.data()), Linears.size(),
2719 const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(),
2720 NewSteps.data(), NewSteps.size(), SR);
2721 ADecl->addAttr(NewAttr);
2722 return ConvertDeclToDeclGroup(ADecl);
2725 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
2727 SourceLocation StartLoc,
2728 SourceLocation EndLoc) {
2732 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
2733 // 1.2.2 OpenMP Language Terminology
2734 // Structured block - An executable statement with a single entry at the
2735 // top and a single exit at the bottom.
2736 // The point of exit cannot be a branch out of the structured block.
2737 // longjmp() and throw() must not violate the entry/exit criteria.
2738 CS->getCapturedDecl()->setNothrow();
2740 getCurFunction()->setHasBranchProtectedScope();
2742 return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
2743 DSAStack->isCancelRegion());
2747 /// \brief Helper class for checking canonical form of the OpenMP loops and
2748 /// extracting iteration space of each loop in the loop nest, that will be used
2749 /// for IR generation.
2750 class OpenMPIterationSpaceChecker {
2751 /// \brief Reference to Sema.
2753 /// \brief A location for diagnostics (when there is no some better location).
2754 SourceLocation DefaultLoc;
2755 /// \brief A location for diagnostics (when increment is not compatible).
2756 SourceLocation ConditionLoc;
2757 /// \brief A source location for referring to loop init later.
2758 SourceRange InitSrcRange;
2759 /// \brief A source location for referring to condition later.
2760 SourceRange ConditionSrcRange;
2761 /// \brief A source location for referring to increment later.
2762 SourceRange IncrementSrcRange;
2763 /// \brief Loop variable.
2764 ValueDecl *LCDecl = nullptr;
2765 /// \brief Reference to loop variable.
2766 Expr *LCRef = nullptr;
2767 /// \brief Lower bound (initializer for the var).
2769 /// \brief Upper bound.
2771 /// \brief Loop step (increment).
2772 Expr *Step = nullptr;
2773 /// \brief This flag is true when condition is one of:
2778 bool TestIsLessOp = false;
2779 /// \brief This flag is true when condition is strict ( < or > ).
2780 bool TestIsStrictOp = false;
2781 /// \brief This flag is true when step is subtracted on each iteration.
2782 bool SubtractStep = false;
2785 OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc)
2786 : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {}
2787 /// \brief Check init-expr for canonical loop form and save loop counter
2788 /// variable - #Var and its initialization value - #LB.
2789 bool CheckInit(Stmt *S, bool EmitDiags = true);
2790 /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags
2791 /// for less/greater and for strict/non-strict comparison.
2792 bool CheckCond(Expr *S);
2793 /// \brief Check incr-expr for canonical loop form and return true if it
2794 /// does not conform, otherwise save loop step (#Step).
2795 bool CheckInc(Expr *S);
2796 /// \brief Return the loop counter variable.
2797 ValueDecl *GetLoopDecl() const { return LCDecl; }
2798 /// \brief Return the reference expression to loop counter variable.
2799 Expr *GetLoopDeclRefExpr() const { return LCRef; }
2800 /// \brief Source range of the loop init.
2801 SourceRange GetInitSrcRange() const { return InitSrcRange; }
2802 /// \brief Source range of the loop condition.
2803 SourceRange GetConditionSrcRange() const { return ConditionSrcRange; }
2804 /// \brief Source range of the loop increment.
2805 SourceRange GetIncrementSrcRange() const { return IncrementSrcRange; }
2806 /// \brief True if the step should be subtracted.
2807 bool ShouldSubtractStep() const { return SubtractStep; }
2808 /// \brief Build the expression to calculate the number of iterations.
2810 BuildNumIterations(Scope *S, const bool LimitedType,
2811 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
2812 /// \brief Build the precondition expression for the loops.
2813 Expr *BuildPreCond(Scope *S, Expr *Cond,
2814 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
2815 /// \brief Build reference expression to the counter be used for codegen.
2816 DeclRefExpr *BuildCounterVar(llvm::MapVector<Expr *, DeclRefExpr *> &Captures,
2817 DSAStackTy &DSA) const;
2818 /// \brief Build reference expression to the private counter be used for
2820 Expr *BuildPrivateCounterVar() const;
2821 /// \brief Build initialization of the counter be used for codegen.
2822 Expr *BuildCounterInit() const;
2823 /// \brief Build step of the counter be used for codegen.
2824 Expr *BuildCounterStep() const;
2825 /// \brief Return true if any expression is dependent.
2826 bool Dependent() const;
2829 /// \brief Check the right-hand side of an assignment in the increment
2831 bool CheckIncRHS(Expr *RHS);
2832 /// \brief Helper to set loop counter variable and its initializer.
2833 bool SetLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB);
2834 /// \brief Helper to set upper bound.
2835 bool SetUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR,
2837 /// \brief Helper to set loop increment.
2838 bool SetStep(Expr *NewStep, bool Subtract);
2841 bool OpenMPIterationSpaceChecker::Dependent() const {
2843 assert(!LB && !UB && !Step);
2846 return LCDecl->getType()->isDependentType() ||
2847 (LB && LB->isValueDependent()) || (UB && UB->isValueDependent()) ||
2848 (Step && Step->isValueDependent());
2851 static Expr *getExprAsWritten(Expr *E) {
2852 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(E))
2853 E = ExprTemp->getSubExpr();
2855 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
2856 E = MTE->GetTemporaryExpr();
2858 while (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
2859 E = Binder->getSubExpr();
2861 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
2862 E = ICE->getSubExprAsWritten();
2863 return E->IgnoreParens();
2866 bool OpenMPIterationSpaceChecker::SetLCDeclAndLB(ValueDecl *NewLCDecl,
2869 // State consistency checking to ensure correct usage.
2870 assert(LCDecl == nullptr && LB == nullptr && LCRef == nullptr &&
2871 UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
2872 if (!NewLCDecl || !NewLB)
2874 LCDecl = getCanonicalDecl(NewLCDecl);
2875 LCRef = NewLCRefExpr;
2876 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(NewLB))
2877 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
2878 if ((Ctor->isCopyOrMoveConstructor() ||
2879 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
2880 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
2881 NewLB = CE->getArg(0)->IgnoreParenImpCasts();
2886 bool OpenMPIterationSpaceChecker::SetUB(Expr *NewUB, bool LessOp, bool StrictOp,
2887 SourceRange SR, SourceLocation SL) {
2888 // State consistency checking to ensure correct usage.
2889 assert(LCDecl != nullptr && LB != nullptr && UB == nullptr &&
2890 Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
2894 TestIsLessOp = LessOp;
2895 TestIsStrictOp = StrictOp;
2896 ConditionSrcRange = SR;
2901 bool OpenMPIterationSpaceChecker::SetStep(Expr *NewStep, bool Subtract) {
2902 // State consistency checking to ensure correct usage.
2903 assert(LCDecl != nullptr && LB != nullptr && Step == nullptr);
2906 if (!NewStep->isValueDependent()) {
2907 // Check that the step is integer expression.
2908 SourceLocation StepLoc = NewStep->getLocStart();
2910 SemaRef.PerformOpenMPImplicitIntegerConversion(StepLoc, NewStep);
2911 if (Val.isInvalid())
2913 NewStep = Val.get();
2915 // OpenMP [2.6, Canonical Loop Form, Restrictions]
2916 // If test-expr is of form var relational-op b and relational-op is < or
2917 // <= then incr-expr must cause var to increase on each iteration of the
2918 // loop. If test-expr is of form var relational-op b and relational-op is
2919 // > or >= then incr-expr must cause var to decrease on each iteration of
2921 // If test-expr is of form b relational-op var and relational-op is < or
2922 // <= then incr-expr must cause var to decrease on each iteration of the
2923 // loop. If test-expr is of form b relational-op var and relational-op is
2924 // > or >= then incr-expr must cause var to increase on each iteration of
2926 llvm::APSInt Result;
2927 bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context);
2928 bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation();
2930 IsConstant && Result.isSigned() && (Subtract != Result.isNegative());
2932 IsConstant && Result.isSigned() && (Subtract == Result.isNegative());
2933 bool IsConstZero = IsConstant && !Result.getBoolValue();
2934 if (UB && (IsConstZero ||
2935 (TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract))
2936 : (IsConstPos || (IsUnsigned && !Subtract))))) {
2937 SemaRef.Diag(NewStep->getExprLoc(),
2938 diag::err_omp_loop_incr_not_compatible)
2939 << LCDecl << TestIsLessOp << NewStep->getSourceRange();
2940 SemaRef.Diag(ConditionLoc,
2941 diag::note_omp_loop_cond_requres_compatible_incr)
2942 << TestIsLessOp << ConditionSrcRange;
2945 if (TestIsLessOp == Subtract) {
2947 SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus, NewStep)
2949 Subtract = !Subtract;
2954 SubtractStep = Subtract;
2958 bool OpenMPIterationSpaceChecker::CheckInit(Stmt *S, bool EmitDiags) {
2959 // Check init-expr for canonical loop form and save loop counter
2960 // variable - #Var and its initialization value - #LB.
2961 // OpenMP [2.6] Canonical loop form. init-expr may be one of the following:
2963 // integer-type var = lb
2964 // random-access-iterator-type var = lb
2965 // pointer-type var = lb
2969 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_init);
2973 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
2974 if (!ExprTemp->cleanupsHaveSideEffects())
2975 S = ExprTemp->getSubExpr();
2977 InitSrcRange = S->getSourceRange();
2978 if (Expr *E = dyn_cast<Expr>(S))
2979 S = E->IgnoreParens();
2980 if (auto *BO = dyn_cast<BinaryOperator>(S)) {
2981 if (BO->getOpcode() == BO_Assign) {
2982 auto *LHS = BO->getLHS()->IgnoreParens();
2983 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
2984 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
2985 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
2986 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
2987 return SetLCDeclAndLB(DRE->getDecl(), DRE, BO->getRHS());
2989 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
2990 if (ME->isArrow() &&
2991 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
2992 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
2995 } else if (auto *DS = dyn_cast<DeclStmt>(S)) {
2996 if (DS->isSingleDecl()) {
2997 if (auto *Var = dyn_cast_or_null<VarDecl>(DS->getSingleDecl())) {
2998 if (Var->hasInit() && !Var->getType()->isReferenceType()) {
2999 // Accept non-canonical init form here but emit ext. warning.
3000 if (Var->getInitStyle() != VarDecl::CInit && EmitDiags)
3001 SemaRef.Diag(S->getLocStart(),
3002 diag::ext_omp_loop_not_canonical_init)
3003 << S->getSourceRange();
3004 return SetLCDeclAndLB(Var, nullptr, Var->getInit());
3008 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3009 if (CE->getOperator() == OO_Equal) {
3010 auto *LHS = CE->getArg(0);
3011 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
3012 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
3013 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3014 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3015 return SetLCDeclAndLB(DRE->getDecl(), DRE, CE->getArg(1));
3017 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
3018 if (ME->isArrow() &&
3019 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3020 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3025 if (Dependent() || SemaRef.CurContext->isDependentContext())
3028 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_init)
3029 << S->getSourceRange();
3034 /// \brief Ignore parenthesizes, implicit casts, copy constructor and return the
3035 /// variable (which may be the loop variable) if possible.
3036 static const ValueDecl *GetInitLCDecl(Expr *E) {
3039 E = getExprAsWritten(E);
3040 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(E))
3041 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
3042 if ((Ctor->isCopyOrMoveConstructor() ||
3043 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
3044 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
3045 E = CE->getArg(0)->IgnoreParenImpCasts();
3046 if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
3047 if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
3048 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
3049 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3050 return getCanonicalDecl(ME->getMemberDecl());
3051 return getCanonicalDecl(VD);
3054 if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
3055 if (ME->isArrow() && isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3056 return getCanonicalDecl(ME->getMemberDecl());
3060 bool OpenMPIterationSpaceChecker::CheckCond(Expr *S) {
3061 // Check test-expr for canonical form, save upper-bound UB, flags for
3062 // less/greater and for strict/non-strict comparison.
3063 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
3064 // var relational-op b
3065 // b relational-op var
3068 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_cond) << LCDecl;
3071 S = getExprAsWritten(S);
3072 SourceLocation CondLoc = S->getLocStart();
3073 if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3074 if (BO->isRelationalOp()) {
3075 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3076 return SetUB(BO->getRHS(),
3077 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_LE),
3078 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
3079 BO->getSourceRange(), BO->getOperatorLoc());
3080 if (GetInitLCDecl(BO->getRHS()) == LCDecl)
3081 return SetUB(BO->getLHS(),
3082 (BO->getOpcode() == BO_GT || BO->getOpcode() == BO_GE),
3083 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
3084 BO->getSourceRange(), BO->getOperatorLoc());
3086 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3087 if (CE->getNumArgs() == 2) {
3088 auto Op = CE->getOperator();
3091 case OO_GreaterEqual:
3094 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3095 return SetUB(CE->getArg(1), Op == OO_Less || Op == OO_LessEqual,
3096 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
3097 CE->getOperatorLoc());
3098 if (GetInitLCDecl(CE->getArg(1)) == LCDecl)
3099 return SetUB(CE->getArg(0), Op == OO_Greater || Op == OO_GreaterEqual,
3100 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
3101 CE->getOperatorLoc());
3108 if (Dependent() || SemaRef.CurContext->isDependentContext())
3110 SemaRef.Diag(CondLoc, diag::err_omp_loop_not_canonical_cond)
3111 << S->getSourceRange() << LCDecl;
3115 bool OpenMPIterationSpaceChecker::CheckIncRHS(Expr *RHS) {
3116 // RHS of canonical loop form increment can be:
3121 RHS = RHS->IgnoreParenImpCasts();
3122 if (auto *BO = dyn_cast<BinaryOperator>(RHS)) {
3123 if (BO->isAdditiveOp()) {
3124 bool IsAdd = BO->getOpcode() == BO_Add;
3125 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3126 return SetStep(BO->getRHS(), !IsAdd);
3127 if (IsAdd && GetInitLCDecl(BO->getRHS()) == LCDecl)
3128 return SetStep(BO->getLHS(), false);
3130 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(RHS)) {
3131 bool IsAdd = CE->getOperator() == OO_Plus;
3132 if ((IsAdd || CE->getOperator() == OO_Minus) && CE->getNumArgs() == 2) {
3133 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3134 return SetStep(CE->getArg(1), !IsAdd);
3135 if (IsAdd && GetInitLCDecl(CE->getArg(1)) == LCDecl)
3136 return SetStep(CE->getArg(0), false);
3139 if (Dependent() || SemaRef.CurContext->isDependentContext())
3141 SemaRef.Diag(RHS->getLocStart(), diag::err_omp_loop_not_canonical_incr)
3142 << RHS->getSourceRange() << LCDecl;
3146 bool OpenMPIterationSpaceChecker::CheckInc(Expr *S) {
3147 // Check incr-expr for canonical loop form and return true if it
3148 // does not conform.
3149 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
3161 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_incr) << LCDecl;
3164 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
3165 if (!ExprTemp->cleanupsHaveSideEffects())
3166 S = ExprTemp->getSubExpr();
3168 IncrementSrcRange = S->getSourceRange();
3169 S = S->IgnoreParens();
3170 if (auto *UO = dyn_cast<UnaryOperator>(S)) {
3171 if (UO->isIncrementDecrementOp() &&
3172 GetInitLCDecl(UO->getSubExpr()) == LCDecl)
3173 return SetStep(SemaRef
3174 .ActOnIntegerConstant(UO->getLocStart(),
3175 (UO->isDecrementOp() ? -1 : 1))
3178 } else if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3179 switch (BO->getOpcode()) {
3182 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3183 return SetStep(BO->getRHS(), BO->getOpcode() == BO_SubAssign);
3186 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3187 return CheckIncRHS(BO->getRHS());
3192 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3193 switch (CE->getOperator()) {
3196 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3197 return SetStep(SemaRef
3198 .ActOnIntegerConstant(
3200 ((CE->getOperator() == OO_MinusMinus) ? -1 : 1))
3206 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3207 return SetStep(CE->getArg(1), CE->getOperator() == OO_MinusEqual);
3210 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3211 return CheckIncRHS(CE->getArg(1));
3217 if (Dependent() || SemaRef.CurContext->isDependentContext())
3219 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_incr)
3220 << S->getSourceRange() << LCDecl;
3225 tryBuildCapture(Sema &SemaRef, Expr *Capture,
3226 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3227 if (SemaRef.CurContext->isDependentContext())
3228 return ExprResult(Capture);
3229 if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects))
3230 return SemaRef.PerformImplicitConversion(
3231 Capture->IgnoreImpCasts(), Capture->getType(), Sema::AA_Converting,
3232 /*AllowExplicit=*/true);
3233 auto I = Captures.find(Capture);
3234 if (I != Captures.end())
3235 return buildCapture(SemaRef, Capture, I->second);
3236 DeclRefExpr *Ref = nullptr;
3237 ExprResult Res = buildCapture(SemaRef, Capture, Ref);
3238 Captures[Capture] = Ref;
3242 /// \brief Build the expression to calculate the number of iterations.
3243 Expr *OpenMPIterationSpaceChecker::BuildNumIterations(
3244 Scope *S, const bool LimitedType,
3245 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
3247 auto VarType = LCDecl->getType().getNonReferenceType();
3248 if (VarType->isIntegerType() || VarType->isPointerType() ||
3249 SemaRef.getLangOpts().CPlusPlus) {
3251 auto *UBExpr = TestIsLessOp ? UB : LB;
3252 auto *LBExpr = TestIsLessOp ? LB : UB;
3253 Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get();
3254 Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get();
3255 if (!Upper || !Lower)
3258 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Sub, Upper, Lower);
3260 if (!Diff.isUsable() && VarType->getAsCXXRecordDecl()) {
3261 // BuildBinOp already emitted error, this one is to point user to upper
3262 // and lower bound, and to tell what is passed to 'operator-'.
3263 SemaRef.Diag(Upper->getLocStart(), diag::err_omp_loop_diff_cxx)
3264 << Upper->getSourceRange() << Lower->getSourceRange();
3269 if (!Diff.isUsable())
3272 // Upper - Lower [- 1]
3274 Diff = SemaRef.BuildBinOp(
3275 S, DefaultLoc, BO_Sub, Diff.get(),
3276 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3277 if (!Diff.isUsable())
3280 // Upper - Lower [- 1] + Step
3281 auto NewStep = tryBuildCapture(SemaRef, Step, Captures);
3282 if (!NewStep.isUsable())
3284 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Add, Diff.get(), NewStep.get());
3285 if (!Diff.isUsable())
3288 // Parentheses (for dumping/debugging purposes only).
3289 Diff = SemaRef.ActOnParenExpr(DefaultLoc, DefaultLoc, Diff.get());
3290 if (!Diff.isUsable())
3293 // (Upper - Lower [- 1] + Step) / Step
3294 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Div, Diff.get(), NewStep.get());
3295 if (!Diff.isUsable())
3298 // OpenMP runtime requires 32-bit or 64-bit loop variables.
3299 QualType Type = Diff.get()->getType();
3300 auto &C = SemaRef.Context;
3301 bool UseVarType = VarType->hasIntegerRepresentation() &&
3302 C.getTypeSize(Type) > C.getTypeSize(VarType);
3303 if (!Type->isIntegerType() || UseVarType) {
3305 UseVarType ? C.getTypeSize(VarType) : C.getTypeSize(Type);
3306 bool IsSigned = UseVarType ? VarType->hasSignedIntegerRepresentation()
3307 : Type->hasSignedIntegerRepresentation();
3308 Type = C.getIntTypeForBitwidth(NewSize, IsSigned);
3309 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), Type)) {
3310 Diff = SemaRef.PerformImplicitConversion(
3311 Diff.get(), Type, Sema::AA_Converting, /*AllowExplicit=*/true);
3312 if (!Diff.isUsable())
3317 unsigned NewSize = (C.getTypeSize(Type) > 32) ? 64 : 32;
3318 if (NewSize != C.getTypeSize(Type)) {
3319 if (NewSize < C.getTypeSize(Type)) {
3320 assert(NewSize == 64 && "incorrect loop var size");
3321 SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var)
3322 << InitSrcRange << ConditionSrcRange;
3324 QualType NewType = C.getIntTypeForBitwidth(
3325 NewSize, Type->hasSignedIntegerRepresentation() ||
3326 C.getTypeSize(Type) < NewSize);
3327 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), NewType)) {
3328 Diff = SemaRef.PerformImplicitConversion(Diff.get(), NewType,
3329 Sema::AA_Converting, true);
3330 if (!Diff.isUsable())
3339 Expr *OpenMPIterationSpaceChecker::BuildPreCond(
3340 Scope *S, Expr *Cond,
3341 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
3342 // Try to build LB <op> UB, where <op> is <, >, <=, or >=.
3343 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
3344 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
3346 auto NewLB = tryBuildCapture(SemaRef, LB, Captures);
3347 auto NewUB = tryBuildCapture(SemaRef, UB, Captures);
3348 if (!NewLB.isUsable() || !NewUB.isUsable())
3351 auto CondExpr = SemaRef.BuildBinOp(
3352 S, DefaultLoc, TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE)
3353 : (TestIsStrictOp ? BO_GT : BO_GE),
3354 NewLB.get(), NewUB.get());
3355 if (CondExpr.isUsable()) {
3356 if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(),
3357 SemaRef.Context.BoolTy))
3358 CondExpr = SemaRef.PerformImplicitConversion(
3359 CondExpr.get(), SemaRef.Context.BoolTy, /*Action=*/Sema::AA_Casting,
3360 /*AllowExplicit=*/true);
3362 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
3363 // Otherwise use original loop conditon and evaluate it in runtime.
3364 return CondExpr.isUsable() ? CondExpr.get() : Cond;
3367 /// \brief Build reference expression to the counter be used for codegen.
3368 DeclRefExpr *OpenMPIterationSpaceChecker::BuildCounterVar(
3369 llvm::MapVector<Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const {
3370 auto *VD = dyn_cast<VarDecl>(LCDecl);
3372 VD = SemaRef.IsOpenMPCapturedDecl(LCDecl);
3373 auto *Ref = buildDeclRefExpr(
3374 SemaRef, VD, VD->getType().getNonReferenceType(), DefaultLoc);
3375 DSAStackTy::DSAVarData Data = DSA.getTopDSA(LCDecl, /*FromParent=*/false);
3376 // If the loop control decl is explicitly marked as private, do not mark it
3377 // as captured again.
3378 if (!isOpenMPPrivate(Data.CKind) || !Data.RefExpr)
3379 Captures.insert(std::make_pair(LCRef, Ref));
3382 return buildDeclRefExpr(SemaRef, VD, VD->getType().getNonReferenceType(),
3386 Expr *OpenMPIterationSpaceChecker::BuildPrivateCounterVar() const {
3387 if (LCDecl && !LCDecl->isInvalidDecl()) {
3388 auto Type = LCDecl->getType().getNonReferenceType();
3390 buildVarDecl(SemaRef, DefaultLoc, Type, LCDecl->getName(),
3391 LCDecl->hasAttrs() ? &LCDecl->getAttrs() : nullptr);
3392 if (PrivateVar->isInvalidDecl())
3394 return buildDeclRefExpr(SemaRef, PrivateVar, Type, DefaultLoc);
3399 /// \brief Build initialization of the counter to be used for codegen.
3400 Expr *OpenMPIterationSpaceChecker::BuildCounterInit() const { return LB; }
3402 /// \brief Build step of the counter be used for codegen.
3403 Expr *OpenMPIterationSpaceChecker::BuildCounterStep() const { return Step; }
3405 /// \brief Iteration space of a single for loop.
3406 struct LoopIterationSpace final {
3407 /// \brief Condition of the loop.
3408 Expr *PreCond = nullptr;
3409 /// \brief This expression calculates the number of iterations in the loop.
3410 /// It is always possible to calculate it before starting the loop.
3411 Expr *NumIterations = nullptr;
3412 /// \brief The loop counter variable.
3413 Expr *CounterVar = nullptr;
3414 /// \brief Private loop counter variable.
3415 Expr *PrivateCounterVar = nullptr;
3416 /// \brief This is initializer for the initial value of #CounterVar.
3417 Expr *CounterInit = nullptr;
3418 /// \brief This is step for the #CounterVar used to generate its update:
3419 /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration.
3420 Expr *CounterStep = nullptr;
3421 /// \brief Should step be subtracted?
3422 bool Subtract = false;
3423 /// \brief Source range of the loop init.
3424 SourceRange InitSrcRange;
3425 /// \brief Source range of the loop condition.
3426 SourceRange CondSrcRange;
3427 /// \brief Source range of the loop increment.
3428 SourceRange IncSrcRange;
3433 void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) {
3434 assert(getLangOpts().OpenMP && "OpenMP is not active.");
3435 assert(Init && "Expected loop in canonical form.");
3436 unsigned AssociatedLoops = DSAStack->getAssociatedLoops();
3437 if (AssociatedLoops > 0 &&
3438 isOpenMPLoopDirective(DSAStack->getCurrentDirective())) {
3439 OpenMPIterationSpaceChecker ISC(*this, ForLoc);
3440 if (!ISC.CheckInit(Init, /*EmitDiags=*/false)) {
3441 if (auto *D = ISC.GetLoopDecl()) {
3442 auto *VD = dyn_cast<VarDecl>(D);
3444 if (auto *Private = IsOpenMPCapturedDecl(D))
3447 auto *Ref = buildCapture(*this, D, ISC.GetLoopDeclRefExpr(),
3448 /*WithInit=*/false);
3449 VD = cast<VarDecl>(Ref->getDecl());
3452 DSAStack->addLoopControlVariable(D, VD);
3455 DSAStack->setAssociatedLoops(AssociatedLoops - 1);
3459 /// \brief Called on a for stmt to check and extract its iteration space
3460 /// for further processing (such as collapsing).
3461 static bool CheckOpenMPIterationSpace(
3462 OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA,
3463 unsigned CurrentNestedLoopCount, unsigned NestedLoopCount,
3464 Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr,
3465 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
3466 LoopIterationSpace &ResultIterSpace,
3467 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3468 // OpenMP [2.6, Canonical Loop Form]
3469 // for (init-expr; test-expr; incr-expr) structured-block
3470 auto *For = dyn_cast_or_null<ForStmt>(S);
3472 SemaRef.Diag(S->getLocStart(), diag::err_omp_not_for)
3473 << (CollapseLoopCountExpr != nullptr || OrderedLoopCountExpr != nullptr)
3474 << getOpenMPDirectiveName(DKind) << NestedLoopCount
3475 << (CurrentNestedLoopCount > 0) << CurrentNestedLoopCount;
3476 if (NestedLoopCount > 1) {
3477 if (CollapseLoopCountExpr && OrderedLoopCountExpr)
3478 SemaRef.Diag(DSA.getConstructLoc(),
3479 diag::note_omp_collapse_ordered_expr)
3480 << 2 << CollapseLoopCountExpr->getSourceRange()
3481 << OrderedLoopCountExpr->getSourceRange();
3482 else if (CollapseLoopCountExpr)
3483 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
3484 diag::note_omp_collapse_ordered_expr)
3485 << 0 << CollapseLoopCountExpr->getSourceRange();
3487 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
3488 diag::note_omp_collapse_ordered_expr)
3489 << 1 << OrderedLoopCountExpr->getSourceRange();
3493 assert(For->getBody());
3495 OpenMPIterationSpaceChecker ISC(SemaRef, For->getForLoc());
3498 auto Init = For->getInit();
3499 if (ISC.CheckInit(Init))
3502 bool HasErrors = false;
3504 // Check loop variable's type.
3505 if (auto *LCDecl = ISC.GetLoopDecl()) {
3506 auto *LoopDeclRefExpr = ISC.GetLoopDeclRefExpr();
3508 // OpenMP [2.6, Canonical Loop Form]
3509 // Var is one of the following:
3510 // A variable of signed or unsigned integer type.
3511 // For C++, a variable of a random access iterator type.
3512 // For C, a variable of a pointer type.
3513 auto VarType = LCDecl->getType().getNonReferenceType();
3514 if (!VarType->isDependentType() && !VarType->isIntegerType() &&
3515 !VarType->isPointerType() &&
3516 !(SemaRef.getLangOpts().CPlusPlus && VarType->isOverloadableType())) {
3517 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_variable_type)
3518 << SemaRef.getLangOpts().CPlusPlus;
3522 // OpenMP, 2.14.1.1 Data-sharing Attribute Rules for Variables Referenced in
3524 // The loop iteration variable(s) in the associated for-loop(s) of a for or
3525 // parallel for construct is (are) private.
3526 // The loop iteration variable in the associated for-loop of a simd
3527 // construct with just one associated for-loop is linear with a
3528 // constant-linear-step that is the increment of the associated for-loop.
3529 // Exclude loop var from the list of variables with implicitly defined data
3530 // sharing attributes.
3531 VarsWithImplicitDSA.erase(LCDecl);
3533 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
3534 // in a Construct, C/C++].
3535 // The loop iteration variable in the associated for-loop of a simd
3536 // construct with just one associated for-loop may be listed in a linear
3537 // clause with a constant-linear-step that is the increment of the
3538 // associated for-loop.
3539 // The loop iteration variable(s) in the associated for-loop(s) of a for or
3540 // parallel for construct may be listed in a private or lastprivate clause.
3541 DSAStackTy::DSAVarData DVar = DSA.getTopDSA(LCDecl, false);
3542 // If LoopVarRefExpr is nullptr it means the corresponding loop variable is
3543 // declared in the loop and it is predetermined as a private.
3544 auto PredeterminedCKind =
3545 isOpenMPSimdDirective(DKind)
3546 ? ((NestedLoopCount == 1) ? OMPC_linear : OMPC_lastprivate)
3548 if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
3549 DVar.CKind != PredeterminedCKind) ||
3550 ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop ||
3551 isOpenMPDistributeDirective(DKind)) &&
3552 !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
3553 DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) &&
3554 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
3555 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_var_dsa)
3556 << getOpenMPClauseName(DVar.CKind) << getOpenMPDirectiveName(DKind)
3557 << getOpenMPClauseName(PredeterminedCKind);
3558 if (DVar.RefExpr == nullptr)
3559 DVar.CKind = PredeterminedCKind;
3560 ReportOriginalDSA(SemaRef, &DSA, LCDecl, DVar, /*IsLoopIterVar=*/true);
3562 } else if (LoopDeclRefExpr != nullptr) {
3563 // Make the loop iteration variable private (for worksharing constructs),
3564 // linear (for simd directives with the only one associated loop) or
3565 // lastprivate (for simd directives with several collapsed or ordered
3567 if (DVar.CKind == OMPC_unknown)
3568 DVar = DSA.hasDSA(LCDecl, isOpenMPPrivate,
3569 [](OpenMPDirectiveKind) -> bool { return true; },
3570 /*FromParent=*/false);
3571 DSA.addDSA(LCDecl, LoopDeclRefExpr, PredeterminedCKind);
3574 assert(isOpenMPLoopDirective(DKind) && "DSA for non-loop vars");
3577 HasErrors |= ISC.CheckCond(For->getCond());
3580 HasErrors |= ISC.CheckInc(For->getInc());
3583 if (ISC.Dependent() || SemaRef.CurContext->isDependentContext() || HasErrors)
3586 // Build the loop's iteration space representation.
3587 ResultIterSpace.PreCond =
3588 ISC.BuildPreCond(DSA.getCurScope(), For->getCond(), Captures);
3589 ResultIterSpace.NumIterations = ISC.BuildNumIterations(
3591 (isOpenMPWorksharingDirective(DKind) ||
3592 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)),
3594 ResultIterSpace.CounterVar = ISC.BuildCounterVar(Captures, DSA);
3595 ResultIterSpace.PrivateCounterVar = ISC.BuildPrivateCounterVar();
3596 ResultIterSpace.CounterInit = ISC.BuildCounterInit();
3597 ResultIterSpace.CounterStep = ISC.BuildCounterStep();
3598 ResultIterSpace.InitSrcRange = ISC.GetInitSrcRange();
3599 ResultIterSpace.CondSrcRange = ISC.GetConditionSrcRange();
3600 ResultIterSpace.IncSrcRange = ISC.GetIncrementSrcRange();
3601 ResultIterSpace.Subtract = ISC.ShouldSubtractStep();
3603 HasErrors |= (ResultIterSpace.PreCond == nullptr ||
3604 ResultIterSpace.NumIterations == nullptr ||
3605 ResultIterSpace.CounterVar == nullptr ||
3606 ResultIterSpace.PrivateCounterVar == nullptr ||
3607 ResultIterSpace.CounterInit == nullptr ||
3608 ResultIterSpace.CounterStep == nullptr);
3613 /// \brief Build 'VarRef = Start.
3615 BuildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef,
3617 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3618 // Build 'VarRef = Start.
3619 auto NewStart = tryBuildCapture(SemaRef, Start.get(), Captures);
3620 if (!NewStart.isUsable())
3622 if (!SemaRef.Context.hasSameType(NewStart.get()->getType(),
3623 VarRef.get()->getType())) {
3624 NewStart = SemaRef.PerformImplicitConversion(
3625 NewStart.get(), VarRef.get()->getType(), Sema::AA_Converting,
3626 /*AllowExplicit=*/true);
3627 if (!NewStart.isUsable())
3632 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
3636 /// \brief Build 'VarRef = Start + Iter * Step'.
3638 BuildCounterUpdate(Sema &SemaRef, Scope *S, SourceLocation Loc,
3639 ExprResult VarRef, ExprResult Start, ExprResult Iter,
3640 ExprResult Step, bool Subtract,
3641 llvm::MapVector<Expr *, DeclRefExpr *> *Captures = nullptr) {
3642 // Add parentheses (for debugging purposes only).
3643 Iter = SemaRef.ActOnParenExpr(Loc, Loc, Iter.get());
3644 if (!VarRef.isUsable() || !Start.isUsable() || !Iter.isUsable() ||
3648 ExprResult NewStep = Step;
3650 NewStep = tryBuildCapture(SemaRef, Step.get(), *Captures);
3651 if (NewStep.isInvalid())
3654 SemaRef.BuildBinOp(S, Loc, BO_Mul, Iter.get(), NewStep.get());
3655 if (!Update.isUsable())
3658 // Try to build 'VarRef = Start, VarRef (+|-)= Iter * Step' or
3659 // 'VarRef = Start (+|-) Iter * Step'.
3660 ExprResult NewStart = Start;
3662 NewStart = tryBuildCapture(SemaRef, Start.get(), *Captures);
3663 if (NewStart.isInvalid())
3666 // First attempt: try to build 'VarRef = Start, VarRef += Iter * Step'.
3667 ExprResult SavedUpdate = Update;
3668 ExprResult UpdateVal;
3669 if (VarRef.get()->getType()->isOverloadableType() ||
3670 NewStart.get()->getType()->isOverloadableType() ||
3671 Update.get()->getType()->isOverloadableType()) {
3672 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
3673 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
3675 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
3676 if (Update.isUsable()) {
3678 SemaRef.BuildBinOp(S, Loc, Subtract ? BO_SubAssign : BO_AddAssign,
3679 VarRef.get(), SavedUpdate.get());
3680 if (UpdateVal.isUsable()) {
3681 Update = SemaRef.CreateBuiltinBinOp(Loc, BO_Comma, Update.get(),
3685 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
3688 // Second attempt: try to build 'VarRef = Start (+|-) Iter * Step'.
3689 if (!Update.isUsable() || !UpdateVal.isUsable()) {
3690 Update = SemaRef.BuildBinOp(S, Loc, Subtract ? BO_Sub : BO_Add,
3691 NewStart.get(), SavedUpdate.get());
3692 if (!Update.isUsable())
3695 if (!SemaRef.Context.hasSameType(Update.get()->getType(),
3696 VarRef.get()->getType())) {
3697 Update = SemaRef.PerformImplicitConversion(
3698 Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true);
3699 if (!Update.isUsable())
3703 Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get());
3708 /// \brief Convert integer expression \a E to make it have at least \a Bits
3710 static ExprResult WidenIterationCount(unsigned Bits, Expr *E, Sema &SemaRef) {
3713 auto &C = SemaRef.Context;
3714 QualType OldType = E->getType();
3715 unsigned HasBits = C.getTypeSize(OldType);
3716 if (HasBits >= Bits)
3717 return ExprResult(E);
3718 // OK to convert to signed, because new type has more bits than old.
3719 QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
3720 return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
3724 /// \brief Check if the given expression \a E is a constant integer that fits
3725 /// into \a Bits bits.
3726 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
3729 llvm::APSInt Result;
3730 if (E->isIntegerConstantExpr(Result, SemaRef.Context))
3731 return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits);
3735 /// Build preinits statement for the given declarations.
3736 static Stmt *buildPreInits(ASTContext &Context,
3737 SmallVectorImpl<Decl *> &PreInits) {
3738 if (!PreInits.empty()) {
3739 return new (Context) DeclStmt(
3740 DeclGroupRef::Create(Context, PreInits.begin(), PreInits.size()),
3741 SourceLocation(), SourceLocation());
3746 /// Build preinits statement for the given declarations.
3747 static Stmt *buildPreInits(ASTContext &Context,
3748 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3749 if (!Captures.empty()) {
3750 SmallVector<Decl *, 16> PreInits;
3751 for (auto &Pair : Captures)
3752 PreInits.push_back(Pair.second->getDecl());
3753 return buildPreInits(Context, PreInits);
3758 /// Build postupdate expression for the given list of postupdates expressions.
3759 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
3760 Expr *PostUpdate = nullptr;
3761 if (!PostUpdates.empty()) {
3762 for (auto *E : PostUpdates) {
3763 Expr *ConvE = S.BuildCStyleCastExpr(
3765 S.Context.getTrivialTypeSourceInfo(S.Context.VoidTy),
3768 PostUpdate = PostUpdate
3769 ? S.CreateBuiltinBinOp(ConvE->getExprLoc(), BO_Comma,
3778 /// \brief Called on a for stmt to check itself and nested loops (if any).
3779 /// \return Returns 0 if one of the collapsed stmts is not canonical for loop,
3780 /// number of collapsed loops otherwise.
3782 CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
3783 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
3785 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
3786 OMPLoopDirective::HelperExprs &Built) {
3787 unsigned NestedLoopCount = 1;
3788 if (CollapseLoopCountExpr) {
3789 // Found 'collapse' clause - calculate collapse number.
3790 llvm::APSInt Result;
3791 if (CollapseLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext()))
3792 NestedLoopCount = Result.getLimitedValue();
3794 if (OrderedLoopCountExpr) {
3795 // Found 'ordered' clause - calculate collapse number.
3796 llvm::APSInt Result;
3797 if (OrderedLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) {
3798 if (Result.getLimitedValue() < NestedLoopCount) {
3799 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
3800 diag::err_omp_wrong_ordered_loop_count)
3801 << OrderedLoopCountExpr->getSourceRange();
3802 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
3803 diag::note_collapse_loop_count)
3804 << CollapseLoopCountExpr->getSourceRange();
3806 NestedLoopCount = Result.getLimitedValue();
3809 // This is helper routine for loop directives (e.g., 'for', 'simd',
3810 // 'for simd', etc.).
3811 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
3812 SmallVector<LoopIterationSpace, 4> IterSpaces;
3813 IterSpaces.resize(NestedLoopCount);
3814 Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true);
3815 for (unsigned Cnt = 0; Cnt < NestedLoopCount; ++Cnt) {
3816 if (CheckOpenMPIterationSpace(DKind, CurStmt, SemaRef, DSA, Cnt,
3817 NestedLoopCount, CollapseLoopCountExpr,
3818 OrderedLoopCountExpr, VarsWithImplicitDSA,
3819 IterSpaces[Cnt], Captures))
3821 // Move on to the next nested for loop, or to the loop body.
3822 // OpenMP [2.8.1, simd construct, Restrictions]
3823 // All loops associated with the construct must be perfectly nested; that
3824 // is, there must be no intervening code nor any OpenMP directive between
3826 CurStmt = cast<ForStmt>(CurStmt)->getBody()->IgnoreContainers();
3829 Built.clear(/* size */ NestedLoopCount);
3831 if (SemaRef.CurContext->isDependentContext())
3832 return NestedLoopCount;
3834 // An example of what is generated for the following code:
3836 // #pragma omp simd collapse(2) ordered(2)
3837 // for (i = 0; i < NI; ++i)
3838 // for (k = 0; k < NK; ++k)
3839 // for (j = J0; j < NJ; j+=2) {
3843 // We generate the code below.
3844 // Note: the loop body may be outlined in CodeGen.
3845 // Note: some counters may be C++ classes, operator- is used to find number of
3846 // iterations and operator+= to calculate counter value.
3847 // Note: decltype(NumIterations) must be integer type (in 'omp for', only i32
3848 // or i64 is currently supported).
3850 // #define NumIterations (NI * ((NJ - J0 - 1 + 2) / 2))
3851 // for (int[32|64]_t IV = 0; IV < NumIterations; ++IV ) {
3852 // .local.i = IV / ((NJ - J0 - 1 + 2) / 2);
3853 // .local.j = J0 + (IV % ((NJ - J0 - 1 + 2) / 2)) * 2;
3854 // // similar updates for vars in clauses (e.g. 'linear')
3855 // <loop body (using local i and j)>
3857 // i = NI; // assign final values of counters
3861 // Last iteration number is (I1 * I2 * ... In) - 1, where I1, I2 ... In are
3862 // the iteration counts of the collapsed for loops.
3863 // Precondition tests if there is at least one iteration (all conditions are
3865 auto PreCond = ExprResult(IterSpaces[0].PreCond);
3866 auto N0 = IterSpaces[0].NumIterations;
3867 ExprResult LastIteration32 = WidenIterationCount(
3868 32 /* Bits */, SemaRef
3869 .PerformImplicitConversion(
3870 N0->IgnoreImpCasts(), N0->getType(),
3871 Sema::AA_Converting, /*AllowExplicit=*/true)
3874 ExprResult LastIteration64 = WidenIterationCount(
3875 64 /* Bits */, SemaRef
3876 .PerformImplicitConversion(
3877 N0->IgnoreImpCasts(), N0->getType(),
3878 Sema::AA_Converting, /*AllowExplicit=*/true)
3882 if (!LastIteration32.isUsable() || !LastIteration64.isUsable())
3883 return NestedLoopCount;
3885 auto &C = SemaRef.Context;
3886 bool AllCountsNeedLessThan32Bits = C.getTypeSize(N0->getType()) < 32;
3888 Scope *CurScope = DSA.getCurScope();
3889 for (unsigned Cnt = 1; Cnt < NestedLoopCount; ++Cnt) {
3890 if (PreCond.isUsable()) {
3892 SemaRef.BuildBinOp(CurScope, PreCond.get()->getExprLoc(), BO_LAnd,
3893 PreCond.get(), IterSpaces[Cnt].PreCond);
3895 auto N = IterSpaces[Cnt].NumIterations;
3896 SourceLocation Loc = N->getExprLoc();
3897 AllCountsNeedLessThan32Bits &= C.getTypeSize(N->getType()) < 32;
3898 if (LastIteration32.isUsable())
3899 LastIteration32 = SemaRef.BuildBinOp(
3900 CurScope, Loc, BO_Mul, LastIteration32.get(),
3902 .PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
3903 Sema::AA_Converting,
3904 /*AllowExplicit=*/true)
3906 if (LastIteration64.isUsable())
3907 LastIteration64 = SemaRef.BuildBinOp(
3908 CurScope, Loc, BO_Mul, LastIteration64.get(),
3910 .PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
3911 Sema::AA_Converting,
3912 /*AllowExplicit=*/true)
3916 // Choose either the 32-bit or 64-bit version.
3917 ExprResult LastIteration = LastIteration64;
3918 if (LastIteration32.isUsable() &&
3919 C.getTypeSize(LastIteration32.get()->getType()) == 32 &&
3920 (AllCountsNeedLessThan32Bits || NestedLoopCount == 1 ||
3923 LastIteration32.get()->getType()->hasSignedIntegerRepresentation(),
3924 LastIteration64.get(), SemaRef)))
3925 LastIteration = LastIteration32;
3926 QualType VType = LastIteration.get()->getType();
3927 QualType RealVType = VType;
3928 QualType StrideVType = VType;
3929 if (isOpenMPTaskLoopDirective(DKind)) {
3931 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
3933 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
3936 if (!LastIteration.isUsable())
3939 // Save the number of iterations.
3940 ExprResult NumIterations = LastIteration;
3942 LastIteration = SemaRef.BuildBinOp(
3943 CurScope, LastIteration.get()->getExprLoc(), BO_Sub,
3944 LastIteration.get(),
3945 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3946 if (!LastIteration.isUsable())
3950 // Calculate the last iteration number beforehand instead of doing this on
3951 // each iteration. Do not do this if the number of iterations may be kfold-ed.
3952 llvm::APSInt Result;
3954 LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context);
3955 ExprResult CalcLastIteration;
3957 ExprResult SaveRef =
3958 tryBuildCapture(SemaRef, LastIteration.get(), Captures);
3959 LastIteration = SaveRef;
3961 // Prepare SaveRef + 1.
3962 NumIterations = SemaRef.BuildBinOp(
3963 CurScope, SaveRef.get()->getExprLoc(), BO_Add, SaveRef.get(),
3964 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3965 if (!NumIterations.isUsable())
3969 SourceLocation InitLoc = IterSpaces[0].InitSrcRange.getBegin();
3971 // Build variables passed into runtime, necessary for worksharing directives.
3972 ExprResult LB, UB, IL, ST, EUB, PrevLB, PrevUB;
3973 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
3974 isOpenMPDistributeDirective(DKind)) {
3975 // Lower bound variable, initialized with zero.
3976 VarDecl *LBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.lb");
3977 LB = buildDeclRefExpr(SemaRef, LBDecl, VType, InitLoc);
3978 SemaRef.AddInitializerToDecl(LBDecl,
3979 SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
3980 /*DirectInit*/ false);
3982 // Upper bound variable, initialized with last iteration number.
3983 VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
3984 UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
3985 SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
3986 /*DirectInit*/ false);
3988 // A 32-bit variable-flag where runtime returns 1 for the last iteration.
3989 // This will be used to implement clause 'lastprivate'.
3990 QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
3991 VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
3992 IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
3993 SemaRef.AddInitializerToDecl(ILDecl,
3994 SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
3995 /*DirectInit*/ false);
3997 // Stride variable returned by runtime (we initialize it to 1 by default).
3999 buildVarDecl(SemaRef, InitLoc, StrideVType, ".omp.stride");
4000 ST = buildDeclRefExpr(SemaRef, STDecl, StrideVType, InitLoc);
4001 SemaRef.AddInitializerToDecl(STDecl,
4002 SemaRef.ActOnIntegerConstant(InitLoc, 1).get(),
4003 /*DirectInit*/ false);
4005 // Build expression: UB = min(UB, LastIteration)
4006 // It is necessary for CodeGen of directives with static scheduling.
4007 ExprResult IsUBGreater = SemaRef.BuildBinOp(CurScope, InitLoc, BO_GT,
4008 UB.get(), LastIteration.get());
4009 ExprResult CondOp = SemaRef.ActOnConditionalOp(
4010 InitLoc, InitLoc, IsUBGreater.get(), LastIteration.get(), UB.get());
4011 EUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, UB.get(),
4013 EUB = SemaRef.ActOnFinishFullExpr(EUB.get());
4015 // If we have a combined directive that combines 'distribute', 'for' or
4016 // 'simd' we need to be able to access the bounds of the schedule of the
4017 // enclosing region. E.g. in 'distribute parallel for' the bounds obtained
4018 // by scheduling 'distribute' have to be passed to the schedule of 'for'.
4019 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4020 auto *CD = cast<CapturedStmt>(AStmt)->getCapturedDecl();
4022 // We expect to have at least 2 more parameters than the 'parallel'
4023 // directive does - the lower and upper bounds of the previous schedule.
4024 assert(CD->getNumParams() >= 4 &&
4025 "Unexpected number of parameters in loop combined directive");
4027 // Set the proper type for the bounds given what we learned from the
4029 auto *PrevLBDecl = CD->getParam(/*PrevLB=*/2);
4030 auto *PrevUBDecl = CD->getParam(/*PrevUB=*/3);
4032 // Previous lower and upper bounds are obtained from the region
4035 buildDeclRefExpr(SemaRef, PrevLBDecl, PrevLBDecl->getType(), InitLoc);
4037 buildDeclRefExpr(SemaRef, PrevUBDecl, PrevUBDecl->getType(), InitLoc);
4041 // Build the iteration variable and its initialization before loop.
4045 VarDecl *IVDecl = buildVarDecl(SemaRef, InitLoc, RealVType, ".omp.iv");
4046 IV = buildDeclRefExpr(SemaRef, IVDecl, RealVType, InitLoc);
4048 (isOpenMPWorksharingDirective(DKind) ||
4049 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
4051 : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
4052 Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS);
4053 Init = SemaRef.ActOnFinishFullExpr(Init.get());
4056 // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops.
4057 SourceLocation CondLoc;
4059 (isOpenMPWorksharingDirective(DKind) ||
4060 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
4061 ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get())
4062 : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(),
4063 NumIterations.get());
4065 // Loop increment (IV = IV + 1)
4066 SourceLocation IncLoc;
4068 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, IV.get(),
4069 SemaRef.ActOnIntegerConstant(IncLoc, 1).get());
4070 if (!Inc.isUsable())
4072 Inc = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, IV.get(), Inc.get());
4073 Inc = SemaRef.ActOnFinishFullExpr(Inc.get());
4074 if (!Inc.isUsable())
4077 // Increments for worksharing loops (LB = LB + ST; UB = UB + ST).
4078 // Used for directives with static scheduling.
4079 ExprResult NextLB, NextUB;
4080 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
4081 isOpenMPDistributeDirective(DKind)) {
4083 NextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, LB.get(), ST.get());
4084 if (!NextLB.isUsable())
4088 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, LB.get(), NextLB.get());
4089 NextLB = SemaRef.ActOnFinishFullExpr(NextLB.get());
4090 if (!NextLB.isUsable())
4093 NextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, UB.get(), ST.get());
4094 if (!NextUB.isUsable())
4098 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, UB.get(), NextUB.get());
4099 NextUB = SemaRef.ActOnFinishFullExpr(NextUB.get());
4100 if (!NextUB.isUsable())
4104 // Build updates and final values of the loop counters.
4105 bool HasErrors = false;
4106 Built.Counters.resize(NestedLoopCount);
4107 Built.Inits.resize(NestedLoopCount);
4108 Built.Updates.resize(NestedLoopCount);
4109 Built.Finals.resize(NestedLoopCount);
4110 SmallVector<Expr *, 4> LoopMultipliers;
4113 // Go from inner nested loop to outer.
4114 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
4115 LoopIterationSpace &IS = IterSpaces[Cnt];
4116 SourceLocation UpdLoc = IS.IncSrcRange.getBegin();
4117 // Build: Iter = (IV / Div) % IS.NumIters
4118 // where Div is product of previous iterations' IS.NumIters.
4120 if (Div.isUsable()) {
4122 SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Div, IV.get(), Div.get());
4125 assert((Cnt == (int)NestedLoopCount - 1) &&
4126 "unusable div expected on first iteration only");
4129 if (Cnt != 0 && Iter.isUsable())
4130 Iter = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Rem, Iter.get(),
4132 if (!Iter.isUsable()) {
4137 // Build update: IS.CounterVar(Private) = IS.Start + Iter * IS.Step
4138 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IS.CounterVar)->getDecl());
4139 auto *CounterVar = buildDeclRefExpr(SemaRef, VD, IS.CounterVar->getType(),
4140 IS.CounterVar->getExprLoc(),
4141 /*RefersToCapture=*/true);
4142 ExprResult Init = BuildCounterInit(SemaRef, CurScope, UpdLoc, CounterVar,
4143 IS.CounterInit, Captures);
4144 if (!Init.isUsable()) {
4148 ExprResult Update = BuildCounterUpdate(
4149 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, Iter,
4150 IS.CounterStep, IS.Subtract, &Captures);
4151 if (!Update.isUsable()) {
4156 // Build final: IS.CounterVar = IS.Start + IS.NumIters * IS.Step
4157 ExprResult Final = BuildCounterUpdate(
4158 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit,
4159 IS.NumIterations, IS.CounterStep, IS.Subtract, &Captures);
4160 if (!Final.isUsable()) {
4165 // Build Div for the next iteration: Div <- Div * IS.NumIters
4168 Div = IS.NumIterations;
4170 Div = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Mul, Div.get(),
4173 // Add parentheses (for debugging purposes only).
4175 Div = tryBuildCapture(SemaRef, Div.get(), Captures);
4176 if (!Div.isUsable()) {
4180 LoopMultipliers.push_back(Div.get());
4182 if (!Update.isUsable() || !Final.isUsable()) {
4187 Built.Counters[Cnt] = IS.CounterVar;
4188 Built.PrivateCounters[Cnt] = IS.PrivateCounterVar;
4189 Built.Inits[Cnt] = Init.get();
4190 Built.Updates[Cnt] = Update.get();
4191 Built.Finals[Cnt] = Final.get();
4199 Built.IterationVarRef = IV.get();
4200 Built.LastIteration = LastIteration.get();
4201 Built.NumIterations = NumIterations.get();
4202 Built.CalcLastIteration =
4203 SemaRef.ActOnFinishFullExpr(CalcLastIteration.get()).get();
4204 Built.PreCond = PreCond.get();
4205 Built.PreInits = buildPreInits(C, Captures);
4206 Built.Cond = Cond.get();
4207 Built.Init = Init.get();
4208 Built.Inc = Inc.get();
4209 Built.LB = LB.get();
4210 Built.UB = UB.get();
4211 Built.IL = IL.get();
4212 Built.ST = ST.get();
4213 Built.EUB = EUB.get();
4214 Built.NLB = NextLB.get();
4215 Built.NUB = NextUB.get();
4216 Built.PrevLB = PrevLB.get();
4217 Built.PrevUB = PrevUB.get();
4219 Expr *CounterVal = SemaRef.DefaultLvalueConversion(IV.get()).get();
4220 // Fill data for doacross depend clauses.
4221 for (auto Pair : DSA.getDoacrossDependClauses()) {
4222 if (Pair.first->getDependencyKind() == OMPC_DEPEND_source)
4223 Pair.first->setCounterValue(CounterVal);
4225 if (NestedLoopCount != Pair.second.size() ||
4226 NestedLoopCount != LoopMultipliers.size() + 1) {
4227 // Erroneous case - clause has some problems.
4228 Pair.first->setCounterValue(CounterVal);
4231 assert(Pair.first->getDependencyKind() == OMPC_DEPEND_sink);
4232 auto I = Pair.second.rbegin();
4233 auto IS = IterSpaces.rbegin();
4234 auto ILM = LoopMultipliers.rbegin();
4235 Expr *UpCounterVal = CounterVal;
4236 Expr *Multiplier = nullptr;
4237 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
4239 assert(IS->CounterStep);
4240 Expr *NormalizedOffset =
4242 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Div,
4243 I->first, IS->CounterStep)
4248 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Mul,
4249 NormalizedOffset, Multiplier)
4252 assert(I->second == OO_Plus || I->second == OO_Minus);
4253 BinaryOperatorKind BOK = (I->second == OO_Plus) ? BO_Add : BO_Sub;
4254 UpCounterVal = SemaRef
4255 .BuildBinOp(CurScope, I->first->getExprLoc(), BOK,
4256 UpCounterVal, NormalizedOffset)
4264 Pair.first->setCounterValue(UpCounterVal);
4268 return NestedLoopCount;
4271 static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) {
4272 auto CollapseClauses =
4273 OMPExecutableDirective::getClausesOfKind<OMPCollapseClause>(Clauses);
4274 if (CollapseClauses.begin() != CollapseClauses.end())
4275 return (*CollapseClauses.begin())->getNumForLoops();
4279 static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) {
4280 auto OrderedClauses =
4281 OMPExecutableDirective::getClausesOfKind<OMPOrderedClause>(Clauses);
4282 if (OrderedClauses.begin() != OrderedClauses.end())
4283 return (*OrderedClauses.begin())->getNumForLoops();
4287 static bool checkSimdlenSafelenSpecified(Sema &S,
4288 const ArrayRef<OMPClause *> Clauses) {
4289 OMPSafelenClause *Safelen = nullptr;
4290 OMPSimdlenClause *Simdlen = nullptr;
4292 for (auto *Clause : Clauses) {
4293 if (Clause->getClauseKind() == OMPC_safelen)
4294 Safelen = cast<OMPSafelenClause>(Clause);
4295 else if (Clause->getClauseKind() == OMPC_simdlen)
4296 Simdlen = cast<OMPSimdlenClause>(Clause);
4297 if (Safelen && Simdlen)
4301 if (Simdlen && Safelen) {
4302 llvm::APSInt SimdlenRes, SafelenRes;
4303 auto SimdlenLength = Simdlen->getSimdlen();
4304 auto SafelenLength = Safelen->getSafelen();
4305 if (SimdlenLength->isValueDependent() || SimdlenLength->isTypeDependent() ||
4306 SimdlenLength->isInstantiationDependent() ||
4307 SimdlenLength->containsUnexpandedParameterPack())
4309 if (SafelenLength->isValueDependent() || SafelenLength->isTypeDependent() ||
4310 SafelenLength->isInstantiationDependent() ||
4311 SafelenLength->containsUnexpandedParameterPack())
4313 SimdlenLength->EvaluateAsInt(SimdlenRes, S.Context);
4314 SafelenLength->EvaluateAsInt(SafelenRes, S.Context);
4315 // OpenMP 4.5 [2.8.1, simd Construct, Restrictions]
4316 // If both simdlen and safelen clauses are specified, the value of the
4317 // simdlen parameter must be less than or equal to the value of the safelen
4319 if (SimdlenRes > SafelenRes) {
4320 S.Diag(SimdlenLength->getExprLoc(),
4321 diag::err_omp_wrong_simdlen_safelen_values)
4322 << SimdlenLength->getSourceRange() << SafelenLength->getSourceRange();
4329 StmtResult Sema::ActOnOpenMPSimdDirective(
4330 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4331 SourceLocation EndLoc,
4332 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4336 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4337 OMPLoopDirective::HelperExprs B;
4338 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4339 // define the nested loops number.
4340 unsigned NestedLoopCount = CheckOpenMPLoop(
4341 OMPD_simd, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
4342 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
4343 if (NestedLoopCount == 0)
4346 assert((CurContext->isDependentContext() || B.builtAll()) &&
4347 "omp simd loop exprs were not built");
4349 if (!CurContext->isDependentContext()) {
4350 // Finalize the clauses that need pre-built expressions for CodeGen.
4351 for (auto C : Clauses) {
4352 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4353 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4354 B.NumIterations, *this, CurScope,
4360 if (checkSimdlenSafelenSpecified(*this, Clauses))
4363 getCurFunction()->setHasBranchProtectedScope();
4364 return OMPSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4368 StmtResult Sema::ActOnOpenMPForDirective(
4369 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4370 SourceLocation EndLoc,
4371 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4375 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4376 OMPLoopDirective::HelperExprs B;
4377 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4378 // define the nested loops number.
4379 unsigned NestedLoopCount = CheckOpenMPLoop(
4380 OMPD_for, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
4381 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
4382 if (NestedLoopCount == 0)
4385 assert((CurContext->isDependentContext() || B.builtAll()) &&
4386 "omp for loop exprs were not built");
4388 if (!CurContext->isDependentContext()) {
4389 // Finalize the clauses that need pre-built expressions for CodeGen.
4390 for (auto C : Clauses) {
4391 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4392 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4393 B.NumIterations, *this, CurScope,
4399 getCurFunction()->setHasBranchProtectedScope();
4400 return OMPForDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4401 Clauses, AStmt, B, DSAStack->isCancelRegion());
4404 StmtResult Sema::ActOnOpenMPForSimdDirective(
4405 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4406 SourceLocation EndLoc,
4407 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4411 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4412 OMPLoopDirective::HelperExprs B;
4413 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4414 // define the nested loops number.
4415 unsigned NestedLoopCount =
4416 CheckOpenMPLoop(OMPD_for_simd, getCollapseNumberExpr(Clauses),
4417 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
4418 VarsWithImplicitDSA, B);
4419 if (NestedLoopCount == 0)
4422 assert((CurContext->isDependentContext() || B.builtAll()) &&
4423 "omp for simd loop exprs were not built");
4425 if (!CurContext->isDependentContext()) {
4426 // Finalize the clauses that need pre-built expressions for CodeGen.
4427 for (auto C : Clauses) {
4428 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4429 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4430 B.NumIterations, *this, CurScope,
4436 if (checkSimdlenSafelenSpecified(*this, Clauses))
4439 getCurFunction()->setHasBranchProtectedScope();
4440 return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4444 StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
4446 SourceLocation StartLoc,
4447 SourceLocation EndLoc) {
4451 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4452 auto BaseStmt = AStmt;
4453 while (auto *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
4454 BaseStmt = CS->getCapturedStmt();
4455 if (auto *C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
4456 auto S = C->children();
4457 if (S.begin() == S.end())
4459 // All associated statements must be '#pragma omp section' except for
4461 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
4462 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
4464 Diag(SectionStmt->getLocStart(),
4465 diag::err_omp_sections_substmt_not_section);
4468 cast<OMPSectionDirective>(SectionStmt)
4469 ->setHasCancel(DSAStack->isCancelRegion());
4472 Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt);
4476 getCurFunction()->setHasBranchProtectedScope();
4478 return OMPSectionsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
4479 DSAStack->isCancelRegion());
4482 StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
4483 SourceLocation StartLoc,
4484 SourceLocation EndLoc) {
4488 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4490 getCurFunction()->setHasBranchProtectedScope();
4491 DSAStack->setParentCancelRegion(DSAStack->isCancelRegion());
4493 return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt,
4494 DSAStack->isCancelRegion());
4497 StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
4499 SourceLocation StartLoc,
4500 SourceLocation EndLoc) {
4504 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4506 getCurFunction()->setHasBranchProtectedScope();
4508 // OpenMP [2.7.3, single Construct, Restrictions]
4509 // The copyprivate clause must not be used with the nowait clause.
4510 OMPClause *Nowait = nullptr;
4511 OMPClause *Copyprivate = nullptr;
4512 for (auto *Clause : Clauses) {
4513 if (Clause->getClauseKind() == OMPC_nowait)
4515 else if (Clause->getClauseKind() == OMPC_copyprivate)
4516 Copyprivate = Clause;
4517 if (Copyprivate && Nowait) {
4518 Diag(Copyprivate->getLocStart(),
4519 diag::err_omp_single_copyprivate_with_nowait);
4520 Diag(Nowait->getLocStart(), diag::note_omp_nowait_clause_here);
4525 return OMPSingleDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
4528 StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
4529 SourceLocation StartLoc,
4530 SourceLocation EndLoc) {
4534 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4536 getCurFunction()->setHasBranchProtectedScope();
4538 return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt);
4541 StmtResult Sema::ActOnOpenMPCriticalDirective(
4542 const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses,
4543 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
4547 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4549 bool ErrorFound = false;
4551 SourceLocation HintLoc;
4552 bool DependentHint = false;
4553 for (auto *C : Clauses) {
4554 if (C->getClauseKind() == OMPC_hint) {
4555 if (!DirName.getName()) {
4556 Diag(C->getLocStart(), diag::err_omp_hint_clause_no_name);
4559 Expr *E = cast<OMPHintClause>(C)->getHint();
4560 if (E->isTypeDependent() || E->isValueDependent() ||
4561 E->isInstantiationDependent())
4562 DependentHint = true;
4564 Hint = E->EvaluateKnownConstInt(Context);
4565 HintLoc = C->getLocStart();
4571 auto Pair = DSAStack->getCriticalWithHint(DirName);
4572 if (Pair.first && DirName.getName() && !DependentHint) {
4573 if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {
4574 Diag(StartLoc, diag::err_omp_critical_with_hint);
4575 if (HintLoc.isValid()) {
4576 Diag(HintLoc, diag::note_omp_critical_hint_here)
4577 << 0 << Hint.toString(/*Radix=*/10, /*Signed=*/false);
4579 Diag(StartLoc, diag::note_omp_critical_no_hint) << 0;
4580 if (auto *C = Pair.first->getSingleClause<OMPHintClause>()) {
4581 Diag(C->getLocStart(), diag::note_omp_critical_hint_here)
4583 << C->getHint()->EvaluateKnownConstInt(Context).toString(
4584 /*Radix=*/10, /*Signed=*/false);
4586 Diag(Pair.first->getLocStart(), diag::note_omp_critical_no_hint) << 1;
4590 getCurFunction()->setHasBranchProtectedScope();
4592 auto *Dir = OMPCriticalDirective::Create(Context, DirName, StartLoc, EndLoc,
4594 if (!Pair.first && DirName.getName() && !DependentHint)
4595 DSAStack->addCriticalWithHint(Dir, Hint);
4599 StmtResult Sema::ActOnOpenMPParallelForDirective(
4600 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4601 SourceLocation EndLoc,
4602 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4606 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
4607 // 1.2.2 OpenMP Language Terminology
4608 // Structured block - An executable statement with a single entry at the
4609 // top and a single exit at the bottom.
4610 // The point of exit cannot be a branch out of the structured block.
4611 // longjmp() and throw() must not violate the entry/exit criteria.
4612 CS->getCapturedDecl()->setNothrow();
4614 OMPLoopDirective::HelperExprs B;
4615 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4616 // define the nested loops number.
4617 unsigned NestedLoopCount =
4618 CheckOpenMPLoop(OMPD_parallel_for, getCollapseNumberExpr(Clauses),
4619 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
4620 VarsWithImplicitDSA, B);
4621 if (NestedLoopCount == 0)
4624 assert((CurContext->isDependentContext() || B.builtAll()) &&
4625 "omp parallel for loop exprs were not built");
4627 if (!CurContext->isDependentContext()) {
4628 // Finalize the clauses that need pre-built expressions for CodeGen.
4629 for (auto C : Clauses) {
4630 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4631 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4632 B.NumIterations, *this, CurScope,
4638 getCurFunction()->setHasBranchProtectedScope();
4639 return OMPParallelForDirective::Create(Context, StartLoc, EndLoc,
4640 NestedLoopCount, Clauses, AStmt, B,
4641 DSAStack->isCancelRegion());
4644 StmtResult Sema::ActOnOpenMPParallelForSimdDirective(
4645 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4646 SourceLocation EndLoc,
4647 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4651 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
4652 // 1.2.2 OpenMP Language Terminology
4653 // Structured block - An executable statement with a single entry at the
4654 // top and a single exit at the bottom.
4655 // The point of exit cannot be a branch out of the structured block.
4656 // longjmp() and throw() must not violate the entry/exit criteria.
4657 CS->getCapturedDecl()->setNothrow();
4659 OMPLoopDirective::HelperExprs B;
4660 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4661 // define the nested loops number.
4662 unsigned NestedLoopCount =
4663 CheckOpenMPLoop(OMPD_parallel_for_simd, getCollapseNumberExpr(Clauses),
4664 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
4665 VarsWithImplicitDSA, B);
4666 if (NestedLoopCount == 0)
4669 if (!CurContext->isDependentContext()) {
4670 // Finalize the clauses that need pre-built expressions for CodeGen.
4671 for (auto C : Clauses) {
4672 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4673 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4674 B.NumIterations, *this, CurScope,
4680 if (checkSimdlenSafelenSpecified(*this, Clauses))
4683 getCurFunction()->setHasBranchProtectedScope();
4684 return OMPParallelForSimdDirective::Create(
4685 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
4689 Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
4690 Stmt *AStmt, SourceLocation StartLoc,
4691 SourceLocation EndLoc) {
4695 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4696 auto BaseStmt = AStmt;
4697 while (auto *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
4698 BaseStmt = CS->getCapturedStmt();
4699 if (auto *C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
4700 auto S = C->children();
4701 if (S.begin() == S.end())
4703 // All associated statements must be '#pragma omp section' except for
4705 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
4706 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
4708 Diag(SectionStmt->getLocStart(),
4709 diag::err_omp_parallel_sections_substmt_not_section);
4712 cast<OMPSectionDirective>(SectionStmt)
4713 ->setHasCancel(DSAStack->isCancelRegion());
4716 Diag(AStmt->getLocStart(),
4717 diag::err_omp_parallel_sections_not_compound_stmt);
4721 getCurFunction()->setHasBranchProtectedScope();
4723 return OMPParallelSectionsDirective::Create(
4724 Context, StartLoc, EndLoc, Clauses, AStmt, DSAStack->isCancelRegion());
4727 StmtResult Sema::ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
4728 Stmt *AStmt, SourceLocation StartLoc,
4729 SourceLocation EndLoc) {
4733 auto *CS = cast<CapturedStmt>(AStmt);
4734 // 1.2.2 OpenMP Language Terminology
4735 // Structured block - An executable statement with a single entry at the
4736 // top and a single exit at the bottom.
4737 // The point of exit cannot be a branch out of the structured block.
4738 // longjmp() and throw() must not violate the entry/exit criteria.
4739 CS->getCapturedDecl()->setNothrow();
4741 getCurFunction()->setHasBranchProtectedScope();
4743 return OMPTaskDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
4744 DSAStack->isCancelRegion());
4747 StmtResult Sema::ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
4748 SourceLocation EndLoc) {
4749 return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc);
4752 StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
4753 SourceLocation EndLoc) {
4754 return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
4757 StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
4758 SourceLocation EndLoc) {
4759 return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc);
4762 StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt,
4763 SourceLocation StartLoc,
4764 SourceLocation EndLoc) {
4768 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4770 getCurFunction()->setHasBranchProtectedScope();
4772 return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt);
4775 StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
4776 SourceLocation StartLoc,
4777 SourceLocation EndLoc) {
4778 assert(Clauses.size() <= 1 && "Extra clauses in flush directive");
4779 return OMPFlushDirective::Create(Context, StartLoc, EndLoc, Clauses);
4782 StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
4784 SourceLocation StartLoc,
4785 SourceLocation EndLoc) {
4786 OMPClause *DependFound = nullptr;
4787 OMPClause *DependSourceClause = nullptr;
4788 OMPClause *DependSinkClause = nullptr;
4789 bool ErrorFound = false;
4790 OMPThreadsClause *TC = nullptr;
4791 OMPSIMDClause *SC = nullptr;
4792 for (auto *C : Clauses) {
4793 if (auto *DC = dyn_cast<OMPDependClause>(C)) {
4795 if (DC->getDependencyKind() == OMPC_DEPEND_source) {
4796 if (DependSourceClause) {
4797 Diag(C->getLocStart(), diag::err_omp_more_one_clause)
4798 << getOpenMPDirectiveName(OMPD_ordered)
4799 << getOpenMPClauseName(OMPC_depend) << 2;
4802 DependSourceClause = C;
4803 if (DependSinkClause) {
4804 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
4808 } else if (DC->getDependencyKind() == OMPC_DEPEND_sink) {
4809 if (DependSourceClause) {
4810 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
4814 DependSinkClause = C;
4816 } else if (C->getClauseKind() == OMPC_threads)
4817 TC = cast<OMPThreadsClause>(C);
4818 else if (C->getClauseKind() == OMPC_simd)
4819 SC = cast<OMPSIMDClause>(C);
4821 if (!ErrorFound && !SC &&
4822 isOpenMPSimdDirective(DSAStack->getParentDirective())) {
4823 // OpenMP [2.8.1,simd Construct, Restrictions]
4824 // An ordered construct with the simd clause is the only OpenMP construct
4825 // that can appear in the simd region.
4826 Diag(StartLoc, diag::err_omp_prohibited_region_simd);
4828 } else if (DependFound && (TC || SC)) {
4829 Diag(DependFound->getLocStart(), diag::err_omp_depend_clause_thread_simd)
4830 << getOpenMPClauseName(TC ? TC->getClauseKind() : SC->getClauseKind());
4832 } else if (DependFound && !DSAStack->getParentOrderedRegionParam()) {
4833 Diag(DependFound->getLocStart(),
4834 diag::err_omp_ordered_directive_without_param);
4836 } else if (TC || Clauses.empty()) {
4837 if (auto *Param = DSAStack->getParentOrderedRegionParam()) {
4838 SourceLocation ErrLoc = TC ? TC->getLocStart() : StartLoc;
4839 Diag(ErrLoc, diag::err_omp_ordered_directive_with_param)
4841 Diag(Param->getLocStart(), diag::note_omp_ordered_param);
4845 if ((!AStmt && !DependFound) || ErrorFound)
4849 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4851 getCurFunction()->setHasBranchProtectedScope();
4854 return OMPOrderedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
4858 /// \brief Helper class for checking expression in 'omp atomic [update]'
4860 class OpenMPAtomicUpdateChecker {
4861 /// \brief Error results for atomic update expressions.
4862 enum ExprAnalysisErrorCode {
4863 /// \brief A statement is not an expression statement.
4865 /// \brief Expression is not builtin binary or unary operation.
4866 NotABinaryOrUnaryExpression,
4867 /// \brief Unary operation is not post-/pre- increment/decrement operation.
4868 NotAnUnaryIncDecExpression,
4869 /// \brief An expression is not of scalar type.
4871 /// \brief A binary operation is not an assignment operation.
4873 /// \brief RHS part of the binary operation is not a binary expression.
4874 NotABinaryExpression,
4875 /// \brief RHS part is not additive/multiplicative/shift/biwise binary
4878 /// \brief RHS binary operation does not have reference to the updated LHS
4880 NotAnUpdateExpression,
4881 /// \brief No errors is found.
4884 /// \brief Reference to Sema.
4886 /// \brief A location for note diagnostics (when error is found).
4887 SourceLocation NoteLoc;
4888 /// \brief 'x' lvalue part of the source atomic expression.
4890 /// \brief 'expr' rvalue part of the source atomic expression.
4892 /// \brief Helper expression of the form
4893 /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
4894 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
4896 /// \brief Is 'x' a LHS in a RHS part of full update expression. It is
4897 /// important for non-associative operations.
4898 bool IsXLHSInRHSPart;
4899 BinaryOperatorKind Op;
4900 SourceLocation OpLoc;
4901 /// \brief true if the source expression is a postfix unary operation, false
4902 /// if it is a prefix unary operation.
4903 bool IsPostfixUpdate;
4906 OpenMPAtomicUpdateChecker(Sema &SemaRef)
4907 : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr),
4908 IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {}
4909 /// \brief Check specified statement that it is suitable for 'atomic update'
4910 /// constructs and extract 'x', 'expr' and Operation from the original
4911 /// expression. If DiagId and NoteId == 0, then only check is performed
4912 /// without error notification.
4913 /// \param DiagId Diagnostic which should be emitted if error is found.
4914 /// \param NoteId Diagnostic note for the main error message.
4915 /// \return true if statement is not an update expression, false otherwise.
4916 bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0);
4917 /// \brief Return the 'x' lvalue part of the source atomic expression.
4918 Expr *getX() const { return X; }
4919 /// \brief Return the 'expr' rvalue part of the source atomic expression.
4920 Expr *getExpr() const { return E; }
4921 /// \brief Return the update expression used in calculation of the updated
4922 /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
4923 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
4924 Expr *getUpdateExpr() const { return UpdateExpr; }
4925 /// \brief Return true if 'x' is LHS in RHS part of full update expression,
4926 /// false otherwise.
4927 bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
4929 /// \brief true if the source expression is a postfix unary operation, false
4930 /// if it is a prefix unary operation.
4931 bool isPostfixUpdate() const { return IsPostfixUpdate; }
4934 bool checkBinaryOperation(BinaryOperator *AtomicBinOp, unsigned DiagId = 0,
4935 unsigned NoteId = 0);
4939 bool OpenMPAtomicUpdateChecker::checkBinaryOperation(
4940 BinaryOperator *AtomicBinOp, unsigned DiagId, unsigned NoteId) {
4941 ExprAnalysisErrorCode ErrorFound = NoError;
4942 SourceLocation ErrorLoc, NoteLoc;
4943 SourceRange ErrorRange, NoteRange;
4944 // Allowed constructs are:
4945 // x = x binop expr;
4946 // x = expr binop x;
4947 if (AtomicBinOp->getOpcode() == BO_Assign) {
4948 X = AtomicBinOp->getLHS();
4949 if (auto *AtomicInnerBinOp = dyn_cast<BinaryOperator>(
4950 AtomicBinOp->getRHS()->IgnoreParenImpCasts())) {
4951 if (AtomicInnerBinOp->isMultiplicativeOp() ||
4952 AtomicInnerBinOp->isAdditiveOp() || AtomicInnerBinOp->isShiftOp() ||
4953 AtomicInnerBinOp->isBitwiseOp()) {
4954 Op = AtomicInnerBinOp->getOpcode();
4955 OpLoc = AtomicInnerBinOp->getOperatorLoc();
4956 auto *LHS = AtomicInnerBinOp->getLHS();
4957 auto *RHS = AtomicInnerBinOp->getRHS();
4958 llvm::FoldingSetNodeID XId, LHSId, RHSId;
4959 X->IgnoreParenImpCasts()->Profile(XId, SemaRef.getASTContext(),
4960 /*Canonical=*/true);
4961 LHS->IgnoreParenImpCasts()->Profile(LHSId, SemaRef.getASTContext(),
4962 /*Canonical=*/true);
4963 RHS->IgnoreParenImpCasts()->Profile(RHSId, SemaRef.getASTContext(),
4964 /*Canonical=*/true);
4967 IsXLHSInRHSPart = true;
4968 } else if (XId == RHSId) {
4970 IsXLHSInRHSPart = false;
4972 ErrorLoc = AtomicInnerBinOp->getExprLoc();
4973 ErrorRange = AtomicInnerBinOp->getSourceRange();
4974 NoteLoc = X->getExprLoc();
4975 NoteRange = X->getSourceRange();
4976 ErrorFound = NotAnUpdateExpression;
4979 ErrorLoc = AtomicInnerBinOp->getExprLoc();
4980 ErrorRange = AtomicInnerBinOp->getSourceRange();
4981 NoteLoc = AtomicInnerBinOp->getOperatorLoc();
4982 NoteRange = SourceRange(NoteLoc, NoteLoc);
4983 ErrorFound = NotABinaryOperator;
4986 NoteLoc = ErrorLoc = AtomicBinOp->getRHS()->getExprLoc();
4987 NoteRange = ErrorRange = AtomicBinOp->getRHS()->getSourceRange();
4988 ErrorFound = NotABinaryExpression;
4991 ErrorLoc = AtomicBinOp->getExprLoc();
4992 ErrorRange = AtomicBinOp->getSourceRange();
4993 NoteLoc = AtomicBinOp->getOperatorLoc();
4994 NoteRange = SourceRange(NoteLoc, NoteLoc);
4995 ErrorFound = NotAnAssignmentOp;
4997 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
4998 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
4999 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
5001 } else if (SemaRef.CurContext->isDependentContext())
5002 E = X = UpdateExpr = nullptr;
5003 return ErrorFound != NoError;
5006 bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
5008 ExprAnalysisErrorCode ErrorFound = NoError;
5009 SourceLocation ErrorLoc, NoteLoc;
5010 SourceRange ErrorRange, NoteRange;
5011 // Allowed constructs are:
5017 // x = x binop expr;
5018 // x = expr binop x;
5019 if (auto *AtomicBody = dyn_cast<Expr>(S)) {
5020 AtomicBody = AtomicBody->IgnoreParenImpCasts();
5021 if (AtomicBody->getType()->isScalarType() ||
5022 AtomicBody->isInstantiationDependent()) {
5023 if (auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>(
5024 AtomicBody->IgnoreParenImpCasts())) {
5025 // Check for Compound Assignment Operation
5026 Op = BinaryOperator::getOpForCompoundAssignment(
5027 AtomicCompAssignOp->getOpcode());
5028 OpLoc = AtomicCompAssignOp->getOperatorLoc();
5029 E = AtomicCompAssignOp->getRHS();
5030 X = AtomicCompAssignOp->getLHS()->IgnoreParens();
5031 IsXLHSInRHSPart = true;
5032 } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>(
5033 AtomicBody->IgnoreParenImpCasts())) {
5034 // Check for Binary Operation
5035 if (checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
5037 } else if (auto *AtomicUnaryOp = dyn_cast<UnaryOperator>(
5038 AtomicBody->IgnoreParenImpCasts())) {
5039 // Check for Unary Operation
5040 if (AtomicUnaryOp->isIncrementDecrementOp()) {
5041 IsPostfixUpdate = AtomicUnaryOp->isPostfix();
5042 Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub;
5043 OpLoc = AtomicUnaryOp->getOperatorLoc();
5044 X = AtomicUnaryOp->getSubExpr()->IgnoreParens();
5045 E = SemaRef.ActOnIntegerConstant(OpLoc, /*uint64_t Val=*/1).get();
5046 IsXLHSInRHSPart = true;
5048 ErrorFound = NotAnUnaryIncDecExpression;
5049 ErrorLoc = AtomicUnaryOp->getExprLoc();
5050 ErrorRange = AtomicUnaryOp->getSourceRange();
5051 NoteLoc = AtomicUnaryOp->getOperatorLoc();
5052 NoteRange = SourceRange(NoteLoc, NoteLoc);
5054 } else if (!AtomicBody->isInstantiationDependent()) {
5055 ErrorFound = NotABinaryOrUnaryExpression;
5056 NoteLoc = ErrorLoc = AtomicBody->getExprLoc();
5057 NoteRange = ErrorRange = AtomicBody->getSourceRange();
5060 ErrorFound = NotAScalarType;
5061 NoteLoc = ErrorLoc = AtomicBody->getLocStart();
5062 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5065 ErrorFound = NotAnExpression;
5066 NoteLoc = ErrorLoc = S->getLocStart();
5067 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5069 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
5070 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
5071 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
5073 } else if (SemaRef.CurContext->isDependentContext())
5074 E = X = UpdateExpr = nullptr;
5075 if (ErrorFound == NoError && E && X) {
5076 // Build an update expression of form 'OpaqueValueExpr(x) binop
5077 // OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop
5078 // OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression.
5079 auto *OVEX = new (SemaRef.getASTContext())
5080 OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue);
5081 auto *OVEExpr = new (SemaRef.getASTContext())
5082 OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue);
5084 SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr,
5085 IsXLHSInRHSPart ? OVEExpr : OVEX);
5086 if (Update.isInvalid())
5088 Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(),
5090 if (Update.isInvalid())
5092 UpdateExpr = Update.get();
5094 return ErrorFound != NoError;
5097 StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
5099 SourceLocation StartLoc,
5100 SourceLocation EndLoc) {
5104 auto *CS = cast<CapturedStmt>(AStmt);
5105 // 1.2.2 OpenMP Language Terminology
5106 // Structured block - An executable statement with a single entry at the
5107 // top and a single exit at the bottom.
5108 // The point of exit cannot be a branch out of the structured block.
5109 // longjmp() and throw() must not violate the entry/exit criteria.
5110 OpenMPClauseKind AtomicKind = OMPC_unknown;
5111 SourceLocation AtomicKindLoc;
5112 for (auto *C : Clauses) {
5113 if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write ||
5114 C->getClauseKind() == OMPC_update ||
5115 C->getClauseKind() == OMPC_capture) {
5116 if (AtomicKind != OMPC_unknown) {
5117 Diag(C->getLocStart(), diag::err_omp_atomic_several_clauses)
5118 << SourceRange(C->getLocStart(), C->getLocEnd());
5119 Diag(AtomicKindLoc, diag::note_omp_atomic_previous_clause)
5120 << getOpenMPClauseName(AtomicKind);
5122 AtomicKind = C->getClauseKind();
5123 AtomicKindLoc = C->getLocStart();
5128 auto Body = CS->getCapturedStmt();
5129 if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
5130 Body = EWC->getSubExpr();
5136 bool IsXLHSInRHSPart = false;
5137 bool IsPostfixUpdate = false;
5138 // OpenMP [2.12.6, atomic Construct]
5139 // In the next expressions:
5140 // * x and v (as applicable) are both l-value expressions with scalar type.
5141 // * During the execution of an atomic region, multiple syntactic
5142 // occurrences of x must designate the same storage location.
5143 // * Neither of v and expr (as applicable) may access the storage location
5145 // * Neither of x and expr (as applicable) may access the storage location
5147 // * expr is an expression with scalar type.
5148 // * binop is one of +, *, -, /, &, ^, |, <<, or >>.
5149 // * binop, binop=, ++, and -- are not overloaded operators.
5150 // * The expression x binop expr must be numerically equivalent to x binop
5151 // (expr). This requirement is satisfied if the operators in expr have
5152 // precedence greater than binop, or by using parentheses around expr or
5153 // subexpressions of expr.
5154 // * The expression expr binop x must be numerically equivalent to (expr)
5155 // binop x. This requirement is satisfied if the operators in expr have
5156 // precedence equal to or greater than binop, or by using parentheses around
5157 // expr or subexpressions of expr.
5158 // * For forms that allow multiple occurrences of x, the number of times
5159 // that x is evaluated is unspecified.
5160 if (AtomicKind == OMPC_read) {
5167 } ErrorFound = NoError;
5168 SourceLocation ErrorLoc, NoteLoc;
5169 SourceRange ErrorRange, NoteRange;
5170 // If clause is read:
5172 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5174 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5175 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5176 X = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
5177 V = AtomicBinOp->getLHS()->IgnoreParenImpCasts();
5178 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
5179 (V->isInstantiationDependent() || V->getType()->isScalarType())) {
5180 if (!X->isLValue() || !V->isLValue()) {
5181 auto NotLValueExpr = X->isLValue() ? V : X;
5182 ErrorFound = NotAnLValue;
5183 ErrorLoc = AtomicBinOp->getExprLoc();
5184 ErrorRange = AtomicBinOp->getSourceRange();
5185 NoteLoc = NotLValueExpr->getExprLoc();
5186 NoteRange = NotLValueExpr->getSourceRange();
5188 } else if (!X->isInstantiationDependent() ||
5189 !V->isInstantiationDependent()) {
5190 auto NotScalarExpr =
5191 (X->isInstantiationDependent() || X->getType()->isScalarType())
5194 ErrorFound = NotAScalarType;
5195 ErrorLoc = AtomicBinOp->getExprLoc();
5196 ErrorRange = AtomicBinOp->getSourceRange();
5197 NoteLoc = NotScalarExpr->getExprLoc();
5198 NoteRange = NotScalarExpr->getSourceRange();
5200 } else if (!AtomicBody->isInstantiationDependent()) {
5201 ErrorFound = NotAnAssignmentOp;
5202 ErrorLoc = AtomicBody->getExprLoc();
5203 ErrorRange = AtomicBody->getSourceRange();
5204 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5205 : AtomicBody->getExprLoc();
5206 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5207 : AtomicBody->getSourceRange();
5210 ErrorFound = NotAnExpression;
5211 NoteLoc = ErrorLoc = Body->getLocStart();
5212 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5214 if (ErrorFound != NoError) {
5215 Diag(ErrorLoc, diag::err_omp_atomic_read_not_expression_statement)
5217 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
5220 } else if (CurContext->isDependentContext())
5222 } else if (AtomicKind == OMPC_write) {
5229 } ErrorFound = NoError;
5230 SourceLocation ErrorLoc, NoteLoc;
5231 SourceRange ErrorRange, NoteRange;
5232 // If clause is write:
5234 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5236 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5237 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5238 X = AtomicBinOp->getLHS();
5239 E = AtomicBinOp->getRHS();
5240 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
5241 (E->isInstantiationDependent() || E->getType()->isScalarType())) {
5242 if (!X->isLValue()) {
5243 ErrorFound = NotAnLValue;
5244 ErrorLoc = AtomicBinOp->getExprLoc();
5245 ErrorRange = AtomicBinOp->getSourceRange();
5246 NoteLoc = X->getExprLoc();
5247 NoteRange = X->getSourceRange();
5249 } else if (!X->isInstantiationDependent() ||
5250 !E->isInstantiationDependent()) {
5251 auto NotScalarExpr =
5252 (X->isInstantiationDependent() || X->getType()->isScalarType())
5255 ErrorFound = NotAScalarType;
5256 ErrorLoc = AtomicBinOp->getExprLoc();
5257 ErrorRange = AtomicBinOp->getSourceRange();
5258 NoteLoc = NotScalarExpr->getExprLoc();
5259 NoteRange = NotScalarExpr->getSourceRange();
5261 } else if (!AtomicBody->isInstantiationDependent()) {
5262 ErrorFound = NotAnAssignmentOp;
5263 ErrorLoc = AtomicBody->getExprLoc();
5264 ErrorRange = AtomicBody->getSourceRange();
5265 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5266 : AtomicBody->getExprLoc();
5267 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5268 : AtomicBody->getSourceRange();
5271 ErrorFound = NotAnExpression;
5272 NoteLoc = ErrorLoc = Body->getLocStart();
5273 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5275 if (ErrorFound != NoError) {
5276 Diag(ErrorLoc, diag::err_omp_atomic_write_not_expression_statement)
5278 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
5281 } else if (CurContext->isDependentContext())
5283 } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {
5284 // If clause is update:
5290 // x = x binop expr;
5291 // x = expr binop x;
5292 OpenMPAtomicUpdateChecker Checker(*this);
5293 if (Checker.checkStatement(
5294 Body, (AtomicKind == OMPC_update)
5295 ? diag::err_omp_atomic_update_not_expression_statement
5296 : diag::err_omp_atomic_not_expression_statement,
5297 diag::note_omp_atomic_update))
5299 if (!CurContext->isDependentContext()) {
5300 E = Checker.getExpr();
5302 UE = Checker.getUpdateExpr();
5303 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5305 } else if (AtomicKind == OMPC_capture) {
5308 NotACompoundStatement,
5309 NotTwoSubstatements,
5310 NotASpecificExpression,
5312 } ErrorFound = NoError;
5313 SourceLocation ErrorLoc, NoteLoc;
5314 SourceRange ErrorRange, NoteRange;
5315 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5316 // If clause is a capture:
5321 // v = x binop= expr;
5322 // v = x = x binop expr;
5323 // v = x = expr binop x;
5325 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5326 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5327 V = AtomicBinOp->getLHS();
5328 Body = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
5329 OpenMPAtomicUpdateChecker Checker(*this);
5330 if (Checker.checkStatement(
5331 Body, diag::err_omp_atomic_capture_not_expression_statement,
5332 diag::note_omp_atomic_update))
5334 E = Checker.getExpr();
5336 UE = Checker.getUpdateExpr();
5337 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5338 IsPostfixUpdate = Checker.isPostfixUpdate();
5339 } else if (!AtomicBody->isInstantiationDependent()) {
5340 ErrorLoc = AtomicBody->getExprLoc();
5341 ErrorRange = AtomicBody->getSourceRange();
5342 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5343 : AtomicBody->getExprLoc();
5344 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5345 : AtomicBody->getSourceRange();
5346 ErrorFound = NotAnAssignmentOp;
5348 if (ErrorFound != NoError) {
5349 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_expression_statement)
5351 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
5353 } else if (CurContext->isDependentContext()) {
5354 UE = V = E = X = nullptr;
5357 // If clause is a capture:
5358 // { v = x; x = expr; }
5363 // { v = x; x binop= expr; }
5364 // { v = x; x = x binop expr; }
5365 // { v = x; x = expr binop x; }
5370 // { x binop= expr; v = x; }
5371 // { x = x binop expr; v = x; }
5372 // { x = expr binop x; v = x; }
5373 if (auto *CS = dyn_cast<CompoundStmt>(Body)) {
5374 // Check that this is { expr1; expr2; }
5375 if (CS->size() == 2) {
5376 auto *First = CS->body_front();
5377 auto *Second = CS->body_back();
5378 if (auto *EWC = dyn_cast<ExprWithCleanups>(First))
5379 First = EWC->getSubExpr()->IgnoreParenImpCasts();
5380 if (auto *EWC = dyn_cast<ExprWithCleanups>(Second))
5381 Second = EWC->getSubExpr()->IgnoreParenImpCasts();
5382 // Need to find what subexpression is 'v' and what is 'x'.
5383 OpenMPAtomicUpdateChecker Checker(*this);
5384 bool IsUpdateExprFound = !Checker.checkStatement(Second);
5385 BinaryOperator *BinOp = nullptr;
5386 if (IsUpdateExprFound) {
5387 BinOp = dyn_cast<BinaryOperator>(First);
5388 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
5390 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
5395 // { v = x; x binop= expr; }
5396 // { v = x; x = x binop expr; }
5397 // { v = x; x = expr binop x; }
5398 // Check that the first expression has form v = x.
5399 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
5400 llvm::FoldingSetNodeID XId, PossibleXId;
5401 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
5402 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
5403 IsUpdateExprFound = XId == PossibleXId;
5404 if (IsUpdateExprFound) {
5405 V = BinOp->getLHS();
5407 E = Checker.getExpr();
5408 UE = Checker.getUpdateExpr();
5409 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5410 IsPostfixUpdate = true;
5413 if (!IsUpdateExprFound) {
5414 IsUpdateExprFound = !Checker.checkStatement(First);
5416 if (IsUpdateExprFound) {
5417 BinOp = dyn_cast<BinaryOperator>(Second);
5418 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
5420 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
5425 // { x binop= expr; v = x; }
5426 // { x = x binop expr; v = x; }
5427 // { x = expr binop x; v = x; }
5428 // Check that the second expression has form v = x.
5429 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
5430 llvm::FoldingSetNodeID XId, PossibleXId;
5431 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
5432 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
5433 IsUpdateExprFound = XId == PossibleXId;
5434 if (IsUpdateExprFound) {
5435 V = BinOp->getLHS();
5437 E = Checker.getExpr();
5438 UE = Checker.getUpdateExpr();
5439 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5440 IsPostfixUpdate = false;
5444 if (!IsUpdateExprFound) {
5445 // { v = x; x = expr; }
5446 auto *FirstExpr = dyn_cast<Expr>(First);
5447 auto *SecondExpr = dyn_cast<Expr>(Second);
5448 if (!FirstExpr || !SecondExpr ||
5449 !(FirstExpr->isInstantiationDependent() ||
5450 SecondExpr->isInstantiationDependent())) {
5451 auto *FirstBinOp = dyn_cast<BinaryOperator>(First);
5452 if (!FirstBinOp || FirstBinOp->getOpcode() != BO_Assign) {
5453 ErrorFound = NotAnAssignmentOp;
5454 NoteLoc = ErrorLoc = FirstBinOp ? FirstBinOp->getOperatorLoc()
5455 : First->getLocStart();
5456 NoteRange = ErrorRange = FirstBinOp
5457 ? FirstBinOp->getSourceRange()
5458 : SourceRange(ErrorLoc, ErrorLoc);
5460 auto *SecondBinOp = dyn_cast<BinaryOperator>(Second);
5461 if (!SecondBinOp || SecondBinOp->getOpcode() != BO_Assign) {
5462 ErrorFound = NotAnAssignmentOp;
5463 NoteLoc = ErrorLoc = SecondBinOp
5464 ? SecondBinOp->getOperatorLoc()
5465 : Second->getLocStart();
5466 NoteRange = ErrorRange =
5467 SecondBinOp ? SecondBinOp->getSourceRange()
5468 : SourceRange(ErrorLoc, ErrorLoc);
5470 auto *PossibleXRHSInFirst =
5471 FirstBinOp->getRHS()->IgnoreParenImpCasts();
5472 auto *PossibleXLHSInSecond =
5473 SecondBinOp->getLHS()->IgnoreParenImpCasts();
5474 llvm::FoldingSetNodeID X1Id, X2Id;
5475 PossibleXRHSInFirst->Profile(X1Id, Context,
5476 /*Canonical=*/true);
5477 PossibleXLHSInSecond->Profile(X2Id, Context,
5478 /*Canonical=*/true);
5479 IsUpdateExprFound = X1Id == X2Id;
5480 if (IsUpdateExprFound) {
5481 V = FirstBinOp->getLHS();
5482 X = SecondBinOp->getLHS();
5483 E = SecondBinOp->getRHS();
5485 IsXLHSInRHSPart = false;
5486 IsPostfixUpdate = true;
5488 ErrorFound = NotASpecificExpression;
5489 ErrorLoc = FirstBinOp->getExprLoc();
5490 ErrorRange = FirstBinOp->getSourceRange();
5491 NoteLoc = SecondBinOp->getLHS()->getExprLoc();
5492 NoteRange = SecondBinOp->getRHS()->getSourceRange();
5499 NoteLoc = ErrorLoc = Body->getLocStart();
5500 NoteRange = ErrorRange =
5501 SourceRange(Body->getLocStart(), Body->getLocStart());
5502 ErrorFound = NotTwoSubstatements;
5505 NoteLoc = ErrorLoc = Body->getLocStart();
5506 NoteRange = ErrorRange =
5507 SourceRange(Body->getLocStart(), Body->getLocStart());
5508 ErrorFound = NotACompoundStatement;
5510 if (ErrorFound != NoError) {
5511 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement)
5513 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
5515 } else if (CurContext->isDependentContext()) {
5516 UE = V = E = X = nullptr;
5521 getCurFunction()->setHasBranchProtectedScope();
5523 return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5524 X, V, E, UE, IsXLHSInRHSPart,
5528 StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
5530 SourceLocation StartLoc,
5531 SourceLocation EndLoc) {
5535 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5536 // 1.2.2 OpenMP Language Terminology
5537 // Structured block - An executable statement with a single entry at the
5538 // top and a single exit at the bottom.
5539 // The point of exit cannot be a branch out of the structured block.
5540 // longjmp() and throw() must not violate the entry/exit criteria.
5541 CS->getCapturedDecl()->setNothrow();
5543 // OpenMP [2.16, Nesting of Regions]
5544 // If specified, a teams construct must be contained within a target
5545 // construct. That target construct must contain no statements or directives
5546 // outside of the teams construct.
5547 if (DSAStack->hasInnerTeamsRegion()) {
5548 auto S = AStmt->IgnoreContainers(/*IgnoreCaptured*/ true);
5549 bool OMPTeamsFound = true;
5550 if (auto *CS = dyn_cast<CompoundStmt>(S)) {
5551 auto I = CS->body_begin();
5552 while (I != CS->body_end()) {
5553 auto *OED = dyn_cast<OMPExecutableDirective>(*I);
5554 if (!OED || !isOpenMPTeamsDirective(OED->getDirectiveKind())) {
5555 OMPTeamsFound = false;
5560 assert(I != CS->body_end() && "Not found statement");
5563 auto *OED = dyn_cast<OMPExecutableDirective>(S);
5564 OMPTeamsFound = OED && isOpenMPTeamsDirective(OED->getDirectiveKind());
5566 if (!OMPTeamsFound) {
5567 Diag(StartLoc, diag::err_omp_target_contains_not_only_teams);
5568 Diag(DSAStack->getInnerTeamsRegionLoc(),
5569 diag::note_omp_nested_teams_construct_here);
5570 Diag(S->getLocStart(), diag::note_omp_nested_statement_here)
5571 << isa<OMPExecutableDirective>(S);
5576 getCurFunction()->setHasBranchProtectedScope();
5578 return OMPTargetDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5582 Sema::ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
5583 Stmt *AStmt, SourceLocation StartLoc,
5584 SourceLocation EndLoc) {
5588 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5589 // 1.2.2 OpenMP Language Terminology
5590 // Structured block - An executable statement with a single entry at the
5591 // top and a single exit at the bottom.
5592 // The point of exit cannot be a branch out of the structured block.
5593 // longjmp() and throw() must not violate the entry/exit criteria.
5594 CS->getCapturedDecl()->setNothrow();
5596 getCurFunction()->setHasBranchProtectedScope();
5598 return OMPTargetParallelDirective::Create(Context, StartLoc, EndLoc, Clauses,
5602 StmtResult Sema::ActOnOpenMPTargetParallelForDirective(
5603 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5604 SourceLocation EndLoc,
5605 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5609 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5610 // 1.2.2 OpenMP Language Terminology
5611 // Structured block - An executable statement with a single entry at the
5612 // top and a single exit at the bottom.
5613 // The point of exit cannot be a branch out of the structured block.
5614 // longjmp() and throw() must not violate the entry/exit criteria.
5615 CS->getCapturedDecl()->setNothrow();
5617 OMPLoopDirective::HelperExprs B;
5618 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5619 // define the nested loops number.
5620 unsigned NestedLoopCount =
5621 CheckOpenMPLoop(OMPD_target_parallel_for, getCollapseNumberExpr(Clauses),
5622 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5623 VarsWithImplicitDSA, B);
5624 if (NestedLoopCount == 0)
5627 assert((CurContext->isDependentContext() || B.builtAll()) &&
5628 "omp target parallel for loop exprs were not built");
5630 if (!CurContext->isDependentContext()) {
5631 // Finalize the clauses that need pre-built expressions for CodeGen.
5632 for (auto C : Clauses) {
5633 if (auto *LC = dyn_cast<OMPLinearClause>(C))
5634 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5635 B.NumIterations, *this, CurScope,
5641 getCurFunction()->setHasBranchProtectedScope();
5642 return OMPTargetParallelForDirective::Create(Context, StartLoc, EndLoc,
5643 NestedLoopCount, Clauses, AStmt,
5644 B, DSAStack->isCancelRegion());
5647 /// \brief Check for existence of a map clause in the list of clauses.
5648 static bool HasMapClause(ArrayRef<OMPClause *> Clauses) {
5649 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
5651 if (*I != nullptr && (*I)->getClauseKind() == OMPC_map) {
5659 StmtResult Sema::ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
5661 SourceLocation StartLoc,
5662 SourceLocation EndLoc) {
5666 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5668 // OpenMP [2.10.1, Restrictions, p. 97]
5669 // At least one map clause must appear on the directive.
5670 if (!HasMapClause(Clauses)) {
5671 Diag(StartLoc, diag::err_omp_no_map_for_directive)
5672 << getOpenMPDirectiveName(OMPD_target_data);
5676 getCurFunction()->setHasBranchProtectedScope();
5678 return OMPTargetDataDirective::Create(Context, StartLoc, EndLoc, Clauses,
5683 Sema::ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
5684 SourceLocation StartLoc,
5685 SourceLocation EndLoc) {
5686 // OpenMP [2.10.2, Restrictions, p. 99]
5687 // At least one map clause must appear on the directive.
5688 if (!HasMapClause(Clauses)) {
5689 Diag(StartLoc, diag::err_omp_no_map_for_directive)
5690 << getOpenMPDirectiveName(OMPD_target_enter_data);
5694 return OMPTargetEnterDataDirective::Create(Context, StartLoc, EndLoc,
5699 Sema::ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
5700 SourceLocation StartLoc,
5701 SourceLocation EndLoc) {
5702 // OpenMP [2.10.3, Restrictions, p. 102]
5703 // At least one map clause must appear on the directive.
5704 if (!HasMapClause(Clauses)) {
5705 Diag(StartLoc, diag::err_omp_no_map_for_directive)
5706 << getOpenMPDirectiveName(OMPD_target_exit_data);
5710 return OMPTargetExitDataDirective::Create(Context, StartLoc, EndLoc, Clauses);
5713 StmtResult Sema::ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
5714 SourceLocation StartLoc,
5715 SourceLocation EndLoc) {
5716 bool seenMotionClause = false;
5717 for (auto *C : Clauses) {
5718 if (C->getClauseKind() == OMPC_to || C->getClauseKind() == OMPC_from)
5719 seenMotionClause = true;
5721 if (!seenMotionClause) {
5722 Diag(StartLoc, diag::err_omp_at_least_one_motion_clause_required);
5725 return OMPTargetUpdateDirective::Create(Context, StartLoc, EndLoc, Clauses);
5728 StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
5729 Stmt *AStmt, SourceLocation StartLoc,
5730 SourceLocation EndLoc) {
5734 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5735 // 1.2.2 OpenMP Language Terminology
5736 // Structured block - An executable statement with a single entry at the
5737 // top and a single exit at the bottom.
5738 // The point of exit cannot be a branch out of the structured block.
5739 // longjmp() and throw() must not violate the entry/exit criteria.
5740 CS->getCapturedDecl()->setNothrow();
5742 getCurFunction()->setHasBranchProtectedScope();
5744 return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5748 Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
5749 SourceLocation EndLoc,
5750 OpenMPDirectiveKind CancelRegion) {
5751 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
5752 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
5753 Diag(StartLoc, diag::err_omp_wrong_cancel_region)
5754 << getOpenMPDirectiveName(CancelRegion);
5757 if (DSAStack->isParentNowaitRegion()) {
5758 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0;
5761 if (DSAStack->isParentOrderedRegion()) {
5762 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0;
5765 return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc,
5769 StmtResult Sema::ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
5770 SourceLocation StartLoc,
5771 SourceLocation EndLoc,
5772 OpenMPDirectiveKind CancelRegion) {
5773 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
5774 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
5775 Diag(StartLoc, diag::err_omp_wrong_cancel_region)
5776 << getOpenMPDirectiveName(CancelRegion);
5779 if (DSAStack->isParentNowaitRegion()) {
5780 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1;
5783 if (DSAStack->isParentOrderedRegion()) {
5784 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1;
5787 DSAStack->setParentCancelRegion(/*Cancel=*/true);
5788 return OMPCancelDirective::Create(Context, StartLoc, EndLoc, Clauses,
5792 static bool checkGrainsizeNumTasksClauses(Sema &S,
5793 ArrayRef<OMPClause *> Clauses) {
5794 OMPClause *PrevClause = nullptr;
5795 bool ErrorFound = false;
5796 for (auto *C : Clauses) {
5797 if (C->getClauseKind() == OMPC_grainsize ||
5798 C->getClauseKind() == OMPC_num_tasks) {
5801 else if (PrevClause->getClauseKind() != C->getClauseKind()) {
5802 S.Diag(C->getLocStart(),
5803 diag::err_omp_grainsize_num_tasks_mutually_exclusive)
5804 << getOpenMPClauseName(C->getClauseKind())
5805 << getOpenMPClauseName(PrevClause->getClauseKind());
5806 S.Diag(PrevClause->getLocStart(),
5807 diag::note_omp_previous_grainsize_num_tasks)
5808 << getOpenMPClauseName(PrevClause->getClauseKind());
5816 StmtResult Sema::ActOnOpenMPTaskLoopDirective(
5817 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5818 SourceLocation EndLoc,
5819 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5823 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5824 OMPLoopDirective::HelperExprs B;
5825 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5826 // define the nested loops number.
5827 unsigned NestedLoopCount =
5828 CheckOpenMPLoop(OMPD_taskloop, getCollapseNumberExpr(Clauses),
5829 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
5830 VarsWithImplicitDSA, B);
5831 if (NestedLoopCount == 0)
5834 assert((CurContext->isDependentContext() || B.builtAll()) &&
5835 "omp for loop exprs were not built");
5837 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
5838 // The grainsize clause and num_tasks clause are mutually exclusive and may
5839 // not appear on the same taskloop directive.
5840 if (checkGrainsizeNumTasksClauses(*this, Clauses))
5843 getCurFunction()->setHasBranchProtectedScope();
5844 return OMPTaskLoopDirective::Create(Context, StartLoc, EndLoc,
5845 NestedLoopCount, Clauses, AStmt, B);
5848 StmtResult Sema::ActOnOpenMPTaskLoopSimdDirective(
5849 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5850 SourceLocation EndLoc,
5851 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5855 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5856 OMPLoopDirective::HelperExprs B;
5857 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5858 // define the nested loops number.
5859 unsigned NestedLoopCount =
5860 CheckOpenMPLoop(OMPD_taskloop_simd, getCollapseNumberExpr(Clauses),
5861 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
5862 VarsWithImplicitDSA, B);
5863 if (NestedLoopCount == 0)
5866 assert((CurContext->isDependentContext() || B.builtAll()) &&
5867 "omp for loop exprs were not built");
5869 if (!CurContext->isDependentContext()) {
5870 // Finalize the clauses that need pre-built expressions for CodeGen.
5871 for (auto C : Clauses) {
5872 if (auto *LC = dyn_cast<OMPLinearClause>(C))
5873 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5874 B.NumIterations, *this, CurScope,
5880 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
5881 // The grainsize clause and num_tasks clause are mutually exclusive and may
5882 // not appear on the same taskloop directive.
5883 if (checkGrainsizeNumTasksClauses(*this, Clauses))
5886 getCurFunction()->setHasBranchProtectedScope();
5887 return OMPTaskLoopSimdDirective::Create(Context, StartLoc, EndLoc,
5888 NestedLoopCount, Clauses, AStmt, B);
5891 StmtResult Sema::ActOnOpenMPDistributeDirective(
5892 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5893 SourceLocation EndLoc,
5894 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5898 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5899 OMPLoopDirective::HelperExprs B;
5900 // In presence of clause 'collapse' with number of loops, it will
5901 // define the nested loops number.
5902 unsigned NestedLoopCount =
5903 CheckOpenMPLoop(OMPD_distribute, getCollapseNumberExpr(Clauses),
5904 nullptr /*ordered not a clause on distribute*/, AStmt,
5905 *this, *DSAStack, VarsWithImplicitDSA, B);
5906 if (NestedLoopCount == 0)
5909 assert((CurContext->isDependentContext() || B.builtAll()) &&
5910 "omp for loop exprs were not built");
5912 getCurFunction()->setHasBranchProtectedScope();
5913 return OMPDistributeDirective::Create(Context, StartLoc, EndLoc,
5914 NestedLoopCount, Clauses, AStmt, B);
5917 StmtResult Sema::ActOnOpenMPDistributeParallelForDirective(
5918 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5919 SourceLocation EndLoc,
5920 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5924 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5925 // 1.2.2 OpenMP Language Terminology
5926 // Structured block - An executable statement with a single entry at the
5927 // top and a single exit at the bottom.
5928 // The point of exit cannot be a branch out of the structured block.
5929 // longjmp() and throw() must not violate the entry/exit criteria.
5930 CS->getCapturedDecl()->setNothrow();
5932 OMPLoopDirective::HelperExprs B;
5933 // In presence of clause 'collapse' with number of loops, it will
5934 // define the nested loops number.
5935 unsigned NestedLoopCount = CheckOpenMPLoop(
5936 OMPD_distribute_parallel_for, getCollapseNumberExpr(Clauses),
5937 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
5938 VarsWithImplicitDSA, B);
5939 if (NestedLoopCount == 0)
5942 assert((CurContext->isDependentContext() || B.builtAll()) &&
5943 "omp for loop exprs were not built");
5945 getCurFunction()->setHasBranchProtectedScope();
5946 return OMPDistributeParallelForDirective::Create(
5947 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
5950 StmtResult Sema::ActOnOpenMPDistributeParallelForSimdDirective(
5951 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5952 SourceLocation EndLoc,
5953 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5957 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5958 // 1.2.2 OpenMP Language Terminology
5959 // Structured block - An executable statement with a single entry at the
5960 // top and a single exit at the bottom.
5961 // The point of exit cannot be a branch out of the structured block.
5962 // longjmp() and throw() must not violate the entry/exit criteria.
5963 CS->getCapturedDecl()->setNothrow();
5965 OMPLoopDirective::HelperExprs B;
5966 // In presence of clause 'collapse' with number of loops, it will
5967 // define the nested loops number.
5968 unsigned NestedLoopCount = CheckOpenMPLoop(
5969 OMPD_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
5970 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
5971 VarsWithImplicitDSA, B);
5972 if (NestedLoopCount == 0)
5975 assert((CurContext->isDependentContext() || B.builtAll()) &&
5976 "omp for loop exprs were not built");
5978 if (checkSimdlenSafelenSpecified(*this, Clauses))
5981 getCurFunction()->setHasBranchProtectedScope();
5982 return OMPDistributeParallelForSimdDirective::Create(
5983 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
5986 StmtResult Sema::ActOnOpenMPDistributeSimdDirective(
5987 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5988 SourceLocation EndLoc,
5989 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5993 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5994 // 1.2.2 OpenMP Language Terminology
5995 // Structured block - An executable statement with a single entry at the
5996 // top and a single exit at the bottom.
5997 // The point of exit cannot be a branch out of the structured block.
5998 // longjmp() and throw() must not violate the entry/exit criteria.
5999 CS->getCapturedDecl()->setNothrow();
6001 OMPLoopDirective::HelperExprs B;
6002 // In presence of clause 'collapse' with number of loops, it will
6003 // define the nested loops number.
6004 unsigned NestedLoopCount =
6005 CheckOpenMPLoop(OMPD_distribute_simd, getCollapseNumberExpr(Clauses),
6006 nullptr /*ordered not a clause on distribute*/, AStmt,
6007 *this, *DSAStack, VarsWithImplicitDSA, B);
6008 if (NestedLoopCount == 0)
6011 assert((CurContext->isDependentContext() || B.builtAll()) &&
6012 "omp for loop exprs were not built");
6014 if (checkSimdlenSafelenSpecified(*this, Clauses))
6017 getCurFunction()->setHasBranchProtectedScope();
6018 return OMPDistributeSimdDirective::Create(Context, StartLoc, EndLoc,
6019 NestedLoopCount, Clauses, AStmt, B);
6022 StmtResult Sema::ActOnOpenMPTargetParallelForSimdDirective(
6023 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6024 SourceLocation EndLoc,
6025 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6029 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6030 // 1.2.2 OpenMP Language Terminology
6031 // Structured block - An executable statement with a single entry at the
6032 // top and a single exit at the bottom.
6033 // The point of exit cannot be a branch out of the structured block.
6034 // longjmp() and throw() must not violate the entry/exit criteria.
6035 CS->getCapturedDecl()->setNothrow();
6037 OMPLoopDirective::HelperExprs B;
6038 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6039 // define the nested loops number.
6040 unsigned NestedLoopCount = CheckOpenMPLoop(
6041 OMPD_target_parallel_for_simd, getCollapseNumberExpr(Clauses),
6042 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
6043 VarsWithImplicitDSA, B);
6044 if (NestedLoopCount == 0)
6047 assert((CurContext->isDependentContext() || B.builtAll()) &&
6048 "omp target parallel for simd loop exprs were not built");
6050 if (!CurContext->isDependentContext()) {
6051 // Finalize the clauses that need pre-built expressions for CodeGen.
6052 for (auto C : Clauses) {
6053 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6054 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6055 B.NumIterations, *this, CurScope,
6060 if (checkSimdlenSafelenSpecified(*this, Clauses))
6063 getCurFunction()->setHasBranchProtectedScope();
6064 return OMPTargetParallelForSimdDirective::Create(
6065 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6068 StmtResult Sema::ActOnOpenMPTargetSimdDirective(
6069 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6070 SourceLocation EndLoc,
6071 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6075 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6076 // 1.2.2 OpenMP Language Terminology
6077 // Structured block - An executable statement with a single entry at the
6078 // top and a single exit at the bottom.
6079 // The point of exit cannot be a branch out of the structured block.
6080 // longjmp() and throw() must not violate the entry/exit criteria.
6081 CS->getCapturedDecl()->setNothrow();
6083 OMPLoopDirective::HelperExprs B;
6084 // In presence of clause 'collapse' with number of loops, it will define the
6085 // nested loops number.
6086 unsigned NestedLoopCount =
6087 CheckOpenMPLoop(OMPD_target_simd, getCollapseNumberExpr(Clauses),
6088 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
6089 VarsWithImplicitDSA, B);
6090 if (NestedLoopCount == 0)
6093 assert((CurContext->isDependentContext() || B.builtAll()) &&
6094 "omp target simd loop exprs were not built");
6096 if (!CurContext->isDependentContext()) {
6097 // Finalize the clauses that need pre-built expressions for CodeGen.
6098 for (auto C : Clauses) {
6099 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6100 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6101 B.NumIterations, *this, CurScope,
6107 if (checkSimdlenSafelenSpecified(*this, Clauses))
6110 getCurFunction()->setHasBranchProtectedScope();
6111 return OMPTargetSimdDirective::Create(Context, StartLoc, EndLoc,
6112 NestedLoopCount, Clauses, AStmt, B);
6115 StmtResult Sema::ActOnOpenMPTeamsDistributeDirective(
6116 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6117 SourceLocation EndLoc,
6118 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6122 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6123 // 1.2.2 OpenMP Language Terminology
6124 // Structured block - An executable statement with a single entry at the
6125 // top and a single exit at the bottom.
6126 // The point of exit cannot be a branch out of the structured block.
6127 // longjmp() and throw() must not violate the entry/exit criteria.
6128 CS->getCapturedDecl()->setNothrow();
6130 OMPLoopDirective::HelperExprs B;
6131 // In presence of clause 'collapse' with number of loops, it will
6132 // define the nested loops number.
6133 unsigned NestedLoopCount =
6134 CheckOpenMPLoop(OMPD_teams_distribute, getCollapseNumberExpr(Clauses),
6135 nullptr /*ordered not a clause on distribute*/, AStmt,
6136 *this, *DSAStack, VarsWithImplicitDSA, B);
6137 if (NestedLoopCount == 0)
6140 assert((CurContext->isDependentContext() || B.builtAll()) &&
6141 "omp teams distribute loop exprs were not built");
6143 getCurFunction()->setHasBranchProtectedScope();
6144 return OMPTeamsDistributeDirective::Create(
6145 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6148 StmtResult Sema::ActOnOpenMPTeamsDistributeSimdDirective(
6149 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6150 SourceLocation EndLoc,
6151 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6155 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6156 // 1.2.2 OpenMP Language Terminology
6157 // Structured block - An executable statement with a single entry at the
6158 // top and a single exit at the bottom.
6159 // The point of exit cannot be a branch out of the structured block.
6160 // longjmp() and throw() must not violate the entry/exit criteria.
6161 CS->getCapturedDecl()->setNothrow();
6163 OMPLoopDirective::HelperExprs B;
6164 // In presence of clause 'collapse' with number of loops, it will
6165 // define the nested loops number.
6166 unsigned NestedLoopCount = CheckOpenMPLoop(
6167 OMPD_teams_distribute_simd, getCollapseNumberExpr(Clauses),
6168 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6169 VarsWithImplicitDSA, B);
6171 if (NestedLoopCount == 0)
6174 assert((CurContext->isDependentContext() || B.builtAll()) &&
6175 "omp teams distribute simd loop exprs were not built");
6177 if (!CurContext->isDependentContext()) {
6178 // Finalize the clauses that need pre-built expressions for CodeGen.
6179 for (auto C : Clauses) {
6180 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6181 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6182 B.NumIterations, *this, CurScope,
6188 if (checkSimdlenSafelenSpecified(*this, Clauses))
6191 getCurFunction()->setHasBranchProtectedScope();
6192 return OMPTeamsDistributeSimdDirective::Create(
6193 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6196 StmtResult Sema::ActOnOpenMPTeamsDistributeParallelForSimdDirective(
6197 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6198 SourceLocation EndLoc,
6199 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6203 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6204 // 1.2.2 OpenMP Language Terminology
6205 // Structured block - An executable statement with a single entry at the
6206 // top and a single exit at the bottom.
6207 // The point of exit cannot be a branch out of the structured block.
6208 // longjmp() and throw() must not violate the entry/exit criteria.
6209 CS->getCapturedDecl()->setNothrow();
6211 OMPLoopDirective::HelperExprs B;
6212 // In presence of clause 'collapse' with number of loops, it will
6213 // define the nested loops number.
6214 auto NestedLoopCount = CheckOpenMPLoop(
6215 OMPD_teams_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
6216 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6217 VarsWithImplicitDSA, B);
6219 if (NestedLoopCount == 0)
6222 assert((CurContext->isDependentContext() || B.builtAll()) &&
6223 "omp for loop exprs were not built");
6225 if (!CurContext->isDependentContext()) {
6226 // Finalize the clauses that need pre-built expressions for CodeGen.
6227 for (auto C : Clauses) {
6228 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6229 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6230 B.NumIterations, *this, CurScope,
6236 if (checkSimdlenSafelenSpecified(*this, Clauses))
6239 getCurFunction()->setHasBranchProtectedScope();
6240 return OMPTeamsDistributeParallelForSimdDirective::Create(
6241 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6244 StmtResult Sema::ActOnOpenMPTeamsDistributeParallelForDirective(
6245 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6246 SourceLocation EndLoc,
6247 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6251 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6252 // 1.2.2 OpenMP Language Terminology
6253 // Structured block - An executable statement with a single entry at the
6254 // top and a single exit at the bottom.
6255 // The point of exit cannot be a branch out of the structured block.
6256 // longjmp() and throw() must not violate the entry/exit criteria.
6257 CS->getCapturedDecl()->setNothrow();
6259 OMPLoopDirective::HelperExprs B;
6260 // In presence of clause 'collapse' with number of loops, it will
6261 // define the nested loops number.
6262 unsigned NestedLoopCount = CheckOpenMPLoop(
6263 OMPD_teams_distribute_parallel_for, getCollapseNumberExpr(Clauses),
6264 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6265 VarsWithImplicitDSA, B);
6267 if (NestedLoopCount == 0)
6270 assert((CurContext->isDependentContext() || B.builtAll()) &&
6271 "omp for loop exprs were not built");
6273 if (!CurContext->isDependentContext()) {
6274 // Finalize the clauses that need pre-built expressions for CodeGen.
6275 for (auto C : Clauses) {
6276 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6277 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6278 B.NumIterations, *this, CurScope,
6284 getCurFunction()->setHasBranchProtectedScope();
6285 return OMPTeamsDistributeParallelForDirective::Create(
6286 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6289 StmtResult Sema::ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
6291 SourceLocation StartLoc,
6292 SourceLocation EndLoc) {
6296 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6297 // 1.2.2 OpenMP Language Terminology
6298 // Structured block - An executable statement with a single entry at the
6299 // top and a single exit at the bottom.
6300 // The point of exit cannot be a branch out of the structured block.
6301 // longjmp() and throw() must not violate the entry/exit criteria.
6302 CS->getCapturedDecl()->setNothrow();
6304 getCurFunction()->setHasBranchProtectedScope();
6306 return OMPTargetTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses,
6310 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeDirective(
6311 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6312 SourceLocation EndLoc,
6313 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6317 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6318 // 1.2.2 OpenMP Language Terminology
6319 // Structured block - An executable statement with a single entry at the
6320 // top and a single exit at the bottom.
6321 // The point of exit cannot be a branch out of the structured block.
6322 // longjmp() and throw() must not violate the entry/exit criteria.
6323 CS->getCapturedDecl()->setNothrow();
6325 OMPLoopDirective::HelperExprs B;
6326 // In presence of clause 'collapse' with number of loops, it will
6327 // define the nested loops number.
6328 auto NestedLoopCount = CheckOpenMPLoop(
6329 OMPD_target_teams_distribute,
6330 getCollapseNumberExpr(Clauses),
6331 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6332 VarsWithImplicitDSA, B);
6333 if (NestedLoopCount == 0)
6336 assert((CurContext->isDependentContext() || B.builtAll()) &&
6337 "omp target teams distribute loop exprs were not built");
6339 getCurFunction()->setHasBranchProtectedScope();
6340 return OMPTargetTeamsDistributeDirective::Create(
6341 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6344 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeParallelForDirective(
6345 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6346 SourceLocation EndLoc,
6347 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6351 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6352 // 1.2.2 OpenMP Language Terminology
6353 // Structured block - An executable statement with a single entry at the
6354 // top and a single exit at the bottom.
6355 // The point of exit cannot be a branch out of the structured block.
6356 // longjmp() and throw() must not violate the entry/exit criteria.
6357 CS->getCapturedDecl()->setNothrow();
6359 OMPLoopDirective::HelperExprs B;
6360 // In presence of clause 'collapse' with number of loops, it will
6361 // define the nested loops number.
6362 auto NestedLoopCount = CheckOpenMPLoop(
6363 OMPD_target_teams_distribute_parallel_for,
6364 getCollapseNumberExpr(Clauses),
6365 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6366 VarsWithImplicitDSA, B);
6367 if (NestedLoopCount == 0)
6370 assert((CurContext->isDependentContext() || B.builtAll()) &&
6371 "omp target teams distribute parallel for loop exprs were not built");
6373 if (!CurContext->isDependentContext()) {
6374 // Finalize the clauses that need pre-built expressions for CodeGen.
6375 for (auto C : Clauses) {
6376 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6377 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6378 B.NumIterations, *this, CurScope,
6384 getCurFunction()->setHasBranchProtectedScope();
6385 return OMPTargetTeamsDistributeParallelForDirective::Create(
6386 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6389 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
6390 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6391 SourceLocation EndLoc,
6392 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6396 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6397 // 1.2.2 OpenMP Language Terminology
6398 // Structured block - An executable statement with a single entry at the
6399 // top and a single exit at the bottom.
6400 // The point of exit cannot be a branch out of the structured block.
6401 // longjmp() and throw() must not violate the entry/exit criteria.
6402 CS->getCapturedDecl()->setNothrow();
6404 OMPLoopDirective::HelperExprs B;
6405 // In presence of clause 'collapse' with number of loops, it will
6406 // define the nested loops number.
6407 auto NestedLoopCount = CheckOpenMPLoop(
6408 OMPD_target_teams_distribute_parallel_for_simd,
6409 getCollapseNumberExpr(Clauses),
6410 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6411 VarsWithImplicitDSA, B);
6412 if (NestedLoopCount == 0)
6415 assert((CurContext->isDependentContext() || B.builtAll()) &&
6416 "omp target teams distribute parallel for simd loop exprs were not "
6419 if (!CurContext->isDependentContext()) {
6420 // Finalize the clauses that need pre-built expressions for CodeGen.
6421 for (auto C : Clauses) {
6422 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6423 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6424 B.NumIterations, *this, CurScope,
6430 getCurFunction()->setHasBranchProtectedScope();
6431 return OMPTargetTeamsDistributeParallelForSimdDirective::Create(
6432 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6435 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeSimdDirective(
6436 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6437 SourceLocation EndLoc,
6438 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6442 auto *CS = cast<CapturedStmt>(AStmt);
6443 // 1.2.2 OpenMP Language Terminology
6444 // Structured block - An executable statement with a single entry at the
6445 // top and a single exit at the bottom.
6446 // The point of exit cannot be a branch out of the structured block.
6447 // longjmp() and throw() must not violate the entry/exit criteria.
6448 CS->getCapturedDecl()->setNothrow();
6450 OMPLoopDirective::HelperExprs B;
6451 // In presence of clause 'collapse' with number of loops, it will
6452 // define the nested loops number.
6453 auto NestedLoopCount = CheckOpenMPLoop(
6454 OMPD_target_teams_distribute_simd, getCollapseNumberExpr(Clauses),
6455 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6456 VarsWithImplicitDSA, B);
6457 if (NestedLoopCount == 0)
6460 assert((CurContext->isDependentContext() || B.builtAll()) &&
6461 "omp target teams distribute simd loop exprs were not built");
6463 getCurFunction()->setHasBranchProtectedScope();
6464 return OMPTargetTeamsDistributeSimdDirective::Create(
6465 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6468 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
6469 SourceLocation StartLoc,
6470 SourceLocation LParenLoc,
6471 SourceLocation EndLoc) {
6472 OMPClause *Res = nullptr;
6475 Res = ActOnOpenMPFinalClause(Expr, StartLoc, LParenLoc, EndLoc);
6477 case OMPC_num_threads:
6478 Res = ActOnOpenMPNumThreadsClause(Expr, StartLoc, LParenLoc, EndLoc);
6481 Res = ActOnOpenMPSafelenClause(Expr, StartLoc, LParenLoc, EndLoc);
6484 Res = ActOnOpenMPSimdlenClause(Expr, StartLoc, LParenLoc, EndLoc);
6487 Res = ActOnOpenMPCollapseClause(Expr, StartLoc, LParenLoc, EndLoc);
6490 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Expr);
6493 Res = ActOnOpenMPDeviceClause(Expr, StartLoc, LParenLoc, EndLoc);
6495 case OMPC_num_teams:
6496 Res = ActOnOpenMPNumTeamsClause(Expr, StartLoc, LParenLoc, EndLoc);
6498 case OMPC_thread_limit:
6499 Res = ActOnOpenMPThreadLimitClause(Expr, StartLoc, LParenLoc, EndLoc);
6502 Res = ActOnOpenMPPriorityClause(Expr, StartLoc, LParenLoc, EndLoc);
6504 case OMPC_grainsize:
6505 Res = ActOnOpenMPGrainsizeClause(Expr, StartLoc, LParenLoc, EndLoc);
6507 case OMPC_num_tasks:
6508 Res = ActOnOpenMPNumTasksClause(Expr, StartLoc, LParenLoc, EndLoc);
6511 Res = ActOnOpenMPHintClause(Expr, StartLoc, LParenLoc, EndLoc);
6515 case OMPC_proc_bind:
6518 case OMPC_firstprivate:
6519 case OMPC_lastprivate:
6521 case OMPC_reduction:
6525 case OMPC_copyprivate:
6528 case OMPC_mergeable:
6529 case OMPC_threadprivate:
6541 case OMPC_dist_schedule:
6542 case OMPC_defaultmap:
6547 case OMPC_use_device_ptr:
6548 case OMPC_is_device_ptr:
6549 llvm_unreachable("Clause is not allowed.");
6554 OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
6555 Expr *Condition, SourceLocation StartLoc,
6556 SourceLocation LParenLoc,
6557 SourceLocation NameModifierLoc,
6558 SourceLocation ColonLoc,
6559 SourceLocation EndLoc) {
6560 Expr *ValExpr = Condition;
6561 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
6562 !Condition->isInstantiationDependent() &&
6563 !Condition->containsUnexpandedParameterPack()) {
6564 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
6565 if (Val.isInvalid())
6568 ValExpr = MakeFullExpr(Val.get()).get();
6571 return new (Context) OMPIfClause(NameModifier, ValExpr, StartLoc, LParenLoc,
6572 NameModifierLoc, ColonLoc, EndLoc);
6575 OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition,
6576 SourceLocation StartLoc,
6577 SourceLocation LParenLoc,
6578 SourceLocation EndLoc) {
6579 Expr *ValExpr = Condition;
6580 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
6581 !Condition->isInstantiationDependent() &&
6582 !Condition->containsUnexpandedParameterPack()) {
6583 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
6584 if (Val.isInvalid())
6587 ValExpr = MakeFullExpr(Val.get()).get();
6590 return new (Context) OMPFinalClause(ValExpr, StartLoc, LParenLoc, EndLoc);
6592 ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc,
6597 class IntConvertDiagnoser : public ICEConvertDiagnoser {
6599 IntConvertDiagnoser()
6600 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false, false, true) {}
6601 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
6602 QualType T) override {
6603 return S.Diag(Loc, diag::err_omp_not_integral) << T;
6605 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
6606 QualType T) override {
6607 return S.Diag(Loc, diag::err_omp_incomplete_type) << T;
6609 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
6611 QualType ConvTy) override {
6612 return S.Diag(Loc, diag::err_omp_explicit_conversion) << T << ConvTy;
6614 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
6615 QualType ConvTy) override {
6616 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
6617 << ConvTy->isEnumeralType() << ConvTy;
6619 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
6620 QualType T) override {
6621 return S.Diag(Loc, diag::err_omp_ambiguous_conversion) << T;
6623 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
6624 QualType ConvTy) override {
6625 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
6626 << ConvTy->isEnumeralType() << ConvTy;
6628 SemaDiagnosticBuilder diagnoseConversion(Sema &, SourceLocation, QualType,
6629 QualType) override {
6630 llvm_unreachable("conversion functions are permitted");
6633 return PerformContextualImplicitConversion(Loc, Op, ConvertDiagnoser);
6636 static bool IsNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef,
6637 OpenMPClauseKind CKind,
6638 bool StrictlyPositive) {
6639 if (!ValExpr->isTypeDependent() && !ValExpr->isValueDependent() &&
6640 !ValExpr->isInstantiationDependent()) {
6641 SourceLocation Loc = ValExpr->getExprLoc();
6643 SemaRef.PerformOpenMPImplicitIntegerConversion(Loc, ValExpr);
6644 if (Value.isInvalid())
6647 ValExpr = Value.get();
6648 // The expression must evaluate to a non-negative integer value.
6649 llvm::APSInt Result;
6650 if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) &&
6651 Result.isSigned() &&
6652 !((!StrictlyPositive && Result.isNonNegative()) ||
6653 (StrictlyPositive && Result.isStrictlyPositive()))) {
6654 SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
6655 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
6656 << ValExpr->getSourceRange();
6663 OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads,
6664 SourceLocation StartLoc,
6665 SourceLocation LParenLoc,
6666 SourceLocation EndLoc) {
6667 Expr *ValExpr = NumThreads;
6669 // OpenMP [2.5, Restrictions]
6670 // The num_threads expression must evaluate to a positive integer value.
6671 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_threads,
6672 /*StrictlyPositive=*/true))
6675 return new (Context)
6676 OMPNumThreadsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
6679 ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
6680 OpenMPClauseKind CKind,
6681 bool StrictlyPositive) {
6684 if (E->isValueDependent() || E->isTypeDependent() ||
6685 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
6687 llvm::APSInt Result;
6688 ExprResult ICE = VerifyIntegerConstantExpression(E, &Result);
6689 if (ICE.isInvalid())
6691 if ((StrictlyPositive && !Result.isStrictlyPositive()) ||
6692 (!StrictlyPositive && !Result.isNonNegative())) {
6693 Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
6694 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
6695 << E->getSourceRange();
6698 if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
6699 Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
6700 << E->getSourceRange();
6703 if (CKind == OMPC_collapse && DSAStack->getAssociatedLoops() == 1)
6704 DSAStack->setAssociatedLoops(Result.getExtValue());
6705 else if (CKind == OMPC_ordered)
6706 DSAStack->setAssociatedLoops(Result.getExtValue());
6710 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
6711 SourceLocation LParenLoc,
6712 SourceLocation EndLoc) {
6713 // OpenMP [2.8.1, simd construct, Description]
6714 // The parameter of the safelen clause must be a constant
6715 // positive integer expression.
6716 ExprResult Safelen = VerifyPositiveIntegerConstantInClause(Len, OMPC_safelen);
6717 if (Safelen.isInvalid())
6719 return new (Context)
6720 OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc);
6723 OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
6724 SourceLocation LParenLoc,
6725 SourceLocation EndLoc) {
6726 // OpenMP [2.8.1, simd construct, Description]
6727 // The parameter of the simdlen clause must be a constant
6728 // positive integer expression.
6729 ExprResult Simdlen = VerifyPositiveIntegerConstantInClause(Len, OMPC_simdlen);
6730 if (Simdlen.isInvalid())
6732 return new (Context)
6733 OMPSimdlenClause(Simdlen.get(), StartLoc, LParenLoc, EndLoc);
6736 OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops,
6737 SourceLocation StartLoc,
6738 SourceLocation LParenLoc,
6739 SourceLocation EndLoc) {
6740 // OpenMP [2.7.1, loop construct, Description]
6741 // OpenMP [2.8.1, simd construct, Description]
6742 // OpenMP [2.9.6, distribute construct, Description]
6743 // The parameter of the collapse clause must be a constant
6744 // positive integer expression.
6745 ExprResult NumForLoopsResult =
6746 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_collapse);
6747 if (NumForLoopsResult.isInvalid())
6749 return new (Context)
6750 OMPCollapseClause(NumForLoopsResult.get(), StartLoc, LParenLoc, EndLoc);
6753 OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc,
6754 SourceLocation EndLoc,
6755 SourceLocation LParenLoc,
6756 Expr *NumForLoops) {
6757 // OpenMP [2.7.1, loop construct, Description]
6758 // OpenMP [2.8.1, simd construct, Description]
6759 // OpenMP [2.9.6, distribute construct, Description]
6760 // The parameter of the ordered clause must be a constant
6761 // positive integer expression if any.
6762 if (NumForLoops && LParenLoc.isValid()) {
6763 ExprResult NumForLoopsResult =
6764 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered);
6765 if (NumForLoopsResult.isInvalid())
6767 NumForLoops = NumForLoopsResult.get();
6769 NumForLoops = nullptr;
6770 DSAStack->setOrderedRegion(/*IsOrdered=*/true, NumForLoops);
6771 return new (Context)
6772 OMPOrderedClause(NumForLoops, StartLoc, LParenLoc, EndLoc);
6775 OMPClause *Sema::ActOnOpenMPSimpleClause(
6776 OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc,
6777 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {
6778 OMPClause *Res = nullptr;
6782 ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument),
6783 ArgumentLoc, StartLoc, LParenLoc, EndLoc);
6785 case OMPC_proc_bind:
6786 Res = ActOnOpenMPProcBindClause(
6787 static_cast<OpenMPProcBindClauseKind>(Argument), ArgumentLoc, StartLoc,
6792 case OMPC_num_threads:
6798 case OMPC_firstprivate:
6799 case OMPC_lastprivate:
6801 case OMPC_reduction:
6805 case OMPC_copyprivate:
6809 case OMPC_mergeable:
6810 case OMPC_threadprivate:
6822 case OMPC_num_teams:
6823 case OMPC_thread_limit:
6825 case OMPC_grainsize:
6827 case OMPC_num_tasks:
6829 case OMPC_dist_schedule:
6830 case OMPC_defaultmap:
6835 case OMPC_use_device_ptr:
6836 case OMPC_is_device_ptr:
6837 llvm_unreachable("Clause is not allowed.");
6843 getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last,
6844 ArrayRef<unsigned> Exclude = llvm::None) {
6846 unsigned Bound = Last >= 2 ? Last - 2 : 0;
6847 unsigned Skipped = Exclude.size();
6848 auto S = Exclude.begin(), E = Exclude.end();
6849 for (unsigned i = First; i < Last; ++i) {
6850 if (std::find(S, E, i) != E) {
6855 Values += getOpenMPSimpleClauseTypeName(K, i);
6857 if (i == Bound - Skipped)
6859 else if (i != Bound + 1 - Skipped)
6865 OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
6866 SourceLocation KindKwLoc,
6867 SourceLocation StartLoc,
6868 SourceLocation LParenLoc,
6869 SourceLocation EndLoc) {
6870 if (Kind == OMPC_DEFAULT_unknown) {
6871 static_assert(OMPC_DEFAULT_unknown > 0,
6872 "OMPC_DEFAULT_unknown not greater than 0");
6873 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
6874 << getListOfPossibleValues(OMPC_default, /*First=*/0,
6875 /*Last=*/OMPC_DEFAULT_unknown)
6876 << getOpenMPClauseName(OMPC_default);
6880 case OMPC_DEFAULT_none:
6881 DSAStack->setDefaultDSANone(KindKwLoc);
6883 case OMPC_DEFAULT_shared:
6884 DSAStack->setDefaultDSAShared(KindKwLoc);
6886 case OMPC_DEFAULT_unknown:
6887 llvm_unreachable("Clause kind is not allowed.");
6890 return new (Context)
6891 OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
6894 OMPClause *Sema::ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
6895 SourceLocation KindKwLoc,
6896 SourceLocation StartLoc,
6897 SourceLocation LParenLoc,
6898 SourceLocation EndLoc) {
6899 if (Kind == OMPC_PROC_BIND_unknown) {
6900 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
6901 << getListOfPossibleValues(OMPC_proc_bind, /*First=*/0,
6902 /*Last=*/OMPC_PROC_BIND_unknown)
6903 << getOpenMPClauseName(OMPC_proc_bind);
6906 return new (Context)
6907 OMPProcBindClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
6910 OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
6911 OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
6912 SourceLocation StartLoc, SourceLocation LParenLoc,
6913 ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc,
6914 SourceLocation EndLoc) {
6915 OMPClause *Res = nullptr;
6918 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
6919 assert(Argument.size() == NumberOfElements &&
6920 ArgumentLoc.size() == NumberOfElements);
6921 Res = ActOnOpenMPScheduleClause(
6922 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier1]),
6923 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier2]),
6924 static_cast<OpenMPScheduleClauseKind>(Argument[ScheduleKind]), Expr,
6925 StartLoc, LParenLoc, ArgumentLoc[Modifier1], ArgumentLoc[Modifier2],
6926 ArgumentLoc[ScheduleKind], DelimLoc, EndLoc);
6929 assert(Argument.size() == 1 && ArgumentLoc.size() == 1);
6930 Res = ActOnOpenMPIfClause(static_cast<OpenMPDirectiveKind>(Argument.back()),
6931 Expr, StartLoc, LParenLoc, ArgumentLoc.back(),
6934 case OMPC_dist_schedule:
6935 Res = ActOnOpenMPDistScheduleClause(
6936 static_cast<OpenMPDistScheduleClauseKind>(Argument.back()), Expr,
6937 StartLoc, LParenLoc, ArgumentLoc.back(), DelimLoc, EndLoc);
6939 case OMPC_defaultmap:
6940 enum { Modifier, DefaultmapKind };
6941 Res = ActOnOpenMPDefaultmapClause(
6942 static_cast<OpenMPDefaultmapClauseModifier>(Argument[Modifier]),
6943 static_cast<OpenMPDefaultmapClauseKind>(Argument[DefaultmapKind]),
6944 StartLoc, LParenLoc, ArgumentLoc[Modifier], ArgumentLoc[DefaultmapKind],
6948 case OMPC_num_threads:
6953 case OMPC_proc_bind:
6955 case OMPC_firstprivate:
6956 case OMPC_lastprivate:
6958 case OMPC_reduction:
6962 case OMPC_copyprivate:
6966 case OMPC_mergeable:
6967 case OMPC_threadprivate:
6979 case OMPC_num_teams:
6980 case OMPC_thread_limit:
6982 case OMPC_grainsize:
6984 case OMPC_num_tasks:
6990 case OMPC_use_device_ptr:
6991 case OMPC_is_device_ptr:
6992 llvm_unreachable("Clause is not allowed.");
6997 static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1,
6998 OpenMPScheduleClauseModifier M2,
6999 SourceLocation M1Loc, SourceLocation M2Loc) {
7000 if (M1 == OMPC_SCHEDULE_MODIFIER_unknown && M1Loc.isValid()) {
7001 SmallVector<unsigned, 2> Excluded;
7002 if (M2 != OMPC_SCHEDULE_MODIFIER_unknown)
7003 Excluded.push_back(M2);
7004 if (M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic)
7005 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_monotonic);
7006 if (M2 == OMPC_SCHEDULE_MODIFIER_monotonic)
7007 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_nonmonotonic);
7008 S.Diag(M1Loc, diag::err_omp_unexpected_clause_value)
7009 << getListOfPossibleValues(OMPC_schedule,
7010 /*First=*/OMPC_SCHEDULE_MODIFIER_unknown + 1,
7011 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7013 << getOpenMPClauseName(OMPC_schedule);
7019 OMPClause *Sema::ActOnOpenMPScheduleClause(
7020 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
7021 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
7022 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
7023 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
7024 if (checkScheduleModifiers(*this, M1, M2, M1Loc, M2Loc) ||
7025 checkScheduleModifiers(*this, M2, M1, M2Loc, M1Loc))
7027 // OpenMP, 2.7.1, Loop Construct, Restrictions
7028 // Either the monotonic modifier or the nonmonotonic modifier can be specified
7030 if ((M1 == M2 && M1 != OMPC_SCHEDULE_MODIFIER_unknown) ||
7031 (M1 == OMPC_SCHEDULE_MODIFIER_monotonic &&
7032 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) ||
7033 (M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic &&
7034 M2 == OMPC_SCHEDULE_MODIFIER_monotonic)) {
7035 Diag(M2Loc, diag::err_omp_unexpected_schedule_modifier)
7036 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M2)
7037 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M1);
7040 if (Kind == OMPC_SCHEDULE_unknown) {
7042 if (M1Loc.isInvalid() && M2Loc.isInvalid()) {
7043 unsigned Exclude[] = {OMPC_SCHEDULE_unknown};
7044 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7045 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7048 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7049 /*Last=*/OMPC_SCHEDULE_unknown);
7051 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
7052 << Values << getOpenMPClauseName(OMPC_schedule);
7055 // OpenMP, 2.7.1, Loop Construct, Restrictions
7056 // The nonmonotonic modifier can only be specified with schedule(dynamic) or
7057 // schedule(guided).
7058 if ((M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
7059 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
7060 Kind != OMPC_SCHEDULE_dynamic && Kind != OMPC_SCHEDULE_guided) {
7061 Diag(M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ? M1Loc : M2Loc,
7062 diag::err_omp_schedule_nonmonotonic_static);
7065 Expr *ValExpr = ChunkSize;
7066 Stmt *HelperValStmt = nullptr;
7068 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
7069 !ChunkSize->isInstantiationDependent() &&
7070 !ChunkSize->containsUnexpandedParameterPack()) {
7071 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
7073 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
7074 if (Val.isInvalid())
7077 ValExpr = Val.get();
7079 // OpenMP [2.7.1, Restrictions]
7080 // chunk_size must be a loop invariant integer expression with a positive
7082 llvm::APSInt Result;
7083 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
7084 if (Result.isSigned() && !Result.isStrictlyPositive()) {
7085 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
7086 << "schedule" << 1 << ChunkSize->getSourceRange();
7089 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
7090 !CurContext->isDependentContext()) {
7091 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7092 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7093 HelperValStmt = buildPreInits(Context, Captures);
7098 return new (Context)
7099 OMPScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, Kind,
7100 ValExpr, HelperValStmt, M1, M1Loc, M2, M2Loc);
7103 OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
7104 SourceLocation StartLoc,
7105 SourceLocation EndLoc) {
7106 OMPClause *Res = nullptr;
7109 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc);
7112 Res = ActOnOpenMPNowaitClause(StartLoc, EndLoc);
7115 Res = ActOnOpenMPUntiedClause(StartLoc, EndLoc);
7117 case OMPC_mergeable:
7118 Res = ActOnOpenMPMergeableClause(StartLoc, EndLoc);
7121 Res = ActOnOpenMPReadClause(StartLoc, EndLoc);
7124 Res = ActOnOpenMPWriteClause(StartLoc, EndLoc);
7127 Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc);
7130 Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc);
7133 Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
7136 Res = ActOnOpenMPThreadsClause(StartLoc, EndLoc);
7139 Res = ActOnOpenMPSIMDClause(StartLoc, EndLoc);
7142 Res = ActOnOpenMPNogroupClause(StartLoc, EndLoc);
7146 case OMPC_num_threads:
7152 case OMPC_firstprivate:
7153 case OMPC_lastprivate:
7155 case OMPC_reduction:
7159 case OMPC_copyprivate:
7161 case OMPC_proc_bind:
7162 case OMPC_threadprivate:
7167 case OMPC_num_teams:
7168 case OMPC_thread_limit:
7170 case OMPC_grainsize:
7171 case OMPC_num_tasks:
7173 case OMPC_dist_schedule:
7174 case OMPC_defaultmap:
7179 case OMPC_use_device_ptr:
7180 case OMPC_is_device_ptr:
7181 llvm_unreachable("Clause is not allowed.");
7186 OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc,
7187 SourceLocation EndLoc) {
7188 DSAStack->setNowaitRegion();
7189 return new (Context) OMPNowaitClause(StartLoc, EndLoc);
7192 OMPClause *Sema::ActOnOpenMPUntiedClause(SourceLocation StartLoc,
7193 SourceLocation EndLoc) {
7194 return new (Context) OMPUntiedClause(StartLoc, EndLoc);
7197 OMPClause *Sema::ActOnOpenMPMergeableClause(SourceLocation StartLoc,
7198 SourceLocation EndLoc) {
7199 return new (Context) OMPMergeableClause(StartLoc, EndLoc);
7202 OMPClause *Sema::ActOnOpenMPReadClause(SourceLocation StartLoc,
7203 SourceLocation EndLoc) {
7204 return new (Context) OMPReadClause(StartLoc, EndLoc);
7207 OMPClause *Sema::ActOnOpenMPWriteClause(SourceLocation StartLoc,
7208 SourceLocation EndLoc) {
7209 return new (Context) OMPWriteClause(StartLoc, EndLoc);
7212 OMPClause *Sema::ActOnOpenMPUpdateClause(SourceLocation StartLoc,
7213 SourceLocation EndLoc) {
7214 return new (Context) OMPUpdateClause(StartLoc, EndLoc);
7217 OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc,
7218 SourceLocation EndLoc) {
7219 return new (Context) OMPCaptureClause(StartLoc, EndLoc);
7222 OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
7223 SourceLocation EndLoc) {
7224 return new (Context) OMPSeqCstClause(StartLoc, EndLoc);
7227 OMPClause *Sema::ActOnOpenMPThreadsClause(SourceLocation StartLoc,
7228 SourceLocation EndLoc) {
7229 return new (Context) OMPThreadsClause(StartLoc, EndLoc);
7232 OMPClause *Sema::ActOnOpenMPSIMDClause(SourceLocation StartLoc,
7233 SourceLocation EndLoc) {
7234 return new (Context) OMPSIMDClause(StartLoc, EndLoc);
7237 OMPClause *Sema::ActOnOpenMPNogroupClause(SourceLocation StartLoc,
7238 SourceLocation EndLoc) {
7239 return new (Context) OMPNogroupClause(StartLoc, EndLoc);
7242 OMPClause *Sema::ActOnOpenMPVarListClause(
7243 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
7244 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc,
7245 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
7246 const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
7247 OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
7248 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
7249 SourceLocation DepLinMapLoc) {
7250 OMPClause *Res = nullptr;
7253 Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7255 case OMPC_firstprivate:
7256 Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7258 case OMPC_lastprivate:
7259 Res = ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7262 Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc);
7264 case OMPC_reduction:
7265 Res = ActOnOpenMPReductionClause(VarList, StartLoc, LParenLoc, ColonLoc,
7266 EndLoc, ReductionIdScopeSpec, ReductionId);
7269 Res = ActOnOpenMPLinearClause(VarList, TailExpr, StartLoc, LParenLoc,
7270 LinKind, DepLinMapLoc, ColonLoc, EndLoc);
7273 Res = ActOnOpenMPAlignedClause(VarList, TailExpr, StartLoc, LParenLoc,
7277 Res = ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, EndLoc);
7279 case OMPC_copyprivate:
7280 Res = ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7283 Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc);
7286 Res = ActOnOpenMPDependClause(DepKind, DepLinMapLoc, ColonLoc, VarList,
7287 StartLoc, LParenLoc, EndLoc);
7290 Res = ActOnOpenMPMapClause(MapTypeModifier, MapType, IsMapTypeImplicit,
7291 DepLinMapLoc, ColonLoc, VarList, StartLoc,
7295 Res = ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
7298 Res = ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc, EndLoc);
7300 case OMPC_use_device_ptr:
7301 Res = ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
7303 case OMPC_is_device_ptr:
7304 Res = ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
7308 case OMPC_num_threads:
7313 case OMPC_proc_bind:
7318 case OMPC_mergeable:
7319 case OMPC_threadprivate:
7328 case OMPC_num_teams:
7329 case OMPC_thread_limit:
7331 case OMPC_grainsize:
7333 case OMPC_num_tasks:
7335 case OMPC_dist_schedule:
7336 case OMPC_defaultmap:
7339 llvm_unreachable("Clause is not allowed.");
7344 ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
7345 ExprObjectKind OK, SourceLocation Loc) {
7346 ExprResult Res = BuildDeclRefExpr(
7347 Capture, Capture->getType().getNonReferenceType(), VK_LValue, Loc);
7348 if (!Res.isUsable())
7350 if (OK == OK_Ordinary && !getLangOpts().CPlusPlus) {
7351 Res = CreateBuiltinUnaryOp(Loc, UO_Deref, Res.get());
7352 if (!Res.isUsable())
7355 if (VK != VK_LValue && Res.get()->isGLValue()) {
7356 Res = DefaultLvalueConversion(Res.get());
7357 if (!Res.isUsable())
7363 static std::pair<ValueDecl *, bool>
7364 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
7365 SourceRange &ERange, bool AllowArraySection = false) {
7366 if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() ||
7367 RefExpr->containsUnexpandedParameterPack())
7368 return std::make_pair(nullptr, true);
7370 // OpenMP [3.1, C/C++]
7371 // A list item is a variable name.
7372 // OpenMP [2.9.3.3, Restrictions, p.1]
7373 // A variable that is part of another variable (as an array or
7374 // structure element) cannot appear in a private clause.
7375 RefExpr = RefExpr->IgnoreParens();
7380 } IsArrayExpr = NoArrayExpr;
7381 if (AllowArraySection) {
7382 if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) {
7383 auto *Base = ASE->getBase()->IgnoreParenImpCasts();
7384 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
7385 Base = TempASE->getBase()->IgnoreParenImpCasts();
7387 IsArrayExpr = ArraySubscript;
7388 } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) {
7389 auto *Base = OASE->getBase()->IgnoreParenImpCasts();
7390 while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base))
7391 Base = TempOASE->getBase()->IgnoreParenImpCasts();
7392 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
7393 Base = TempASE->getBase()->IgnoreParenImpCasts();
7395 IsArrayExpr = OMPArraySection;
7398 ELoc = RefExpr->getExprLoc();
7399 ERange = RefExpr->getSourceRange();
7400 RefExpr = RefExpr->IgnoreParenImpCasts();
7401 auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
7402 auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr);
7403 if ((!DE || !isa<VarDecl>(DE->getDecl())) &&
7404 (S.getCurrentThisType().isNull() || !ME ||
7405 !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) ||
7406 !isa<FieldDecl>(ME->getMemberDecl()))) {
7407 if (IsArrayExpr != NoArrayExpr)
7408 S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr
7413 ? diag::err_omp_expected_var_name_member_expr_or_array_item
7414 : diag::err_omp_expected_var_name_member_expr)
7415 << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange;
7417 return std::make_pair(nullptr, false);
7419 return std::make_pair(DE ? DE->getDecl() : ME->getMemberDecl(), false);
7422 OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
7423 SourceLocation StartLoc,
7424 SourceLocation LParenLoc,
7425 SourceLocation EndLoc) {
7426 SmallVector<Expr *, 8> Vars;
7427 SmallVector<Expr *, 8> PrivateCopies;
7428 for (auto &RefExpr : VarList) {
7429 assert(RefExpr && "NULL expr in OpenMP private clause.");
7430 SourceLocation ELoc;
7432 Expr *SimpleRefExpr = RefExpr;
7433 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
7435 // It will be analyzed later.
7436 Vars.push_back(RefExpr);
7437 PrivateCopies.push_back(nullptr);
7439 ValueDecl *D = Res.first;
7443 QualType Type = D->getType();
7444 auto *VD = dyn_cast<VarDecl>(D);
7446 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
7447 // A variable that appears in a private clause must not have an incomplete
7448 // type or a reference type.
7449 if (RequireCompleteType(ELoc, Type, diag::err_omp_private_incomplete_type))
7451 Type = Type.getNonReferenceType();
7453 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
7455 // Variables with the predetermined data-sharing attributes may not be
7456 // listed in data-sharing attributes clauses, except for the cases
7457 // listed below. For these exceptions only, listing a predetermined
7458 // variable in a data-sharing attribute clause is allowed and overrides
7459 // the variable's predetermined data-sharing attributes.
7460 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
7461 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) {
7462 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
7463 << getOpenMPClauseName(OMPC_private);
7464 ReportOriginalDSA(*this, DSAStack, D, DVar);
7468 auto CurrDir = DSAStack->getCurrentDirective();
7469 // Variably modified types are not supported for tasks.
7470 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
7471 isOpenMPTaskingDirective(CurrDir)) {
7472 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
7473 << getOpenMPClauseName(OMPC_private) << Type
7474 << getOpenMPDirectiveName(CurrDir);
7477 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
7478 Diag(D->getLocation(),
7479 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
7484 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
7485 // A list item cannot appear in both a map clause and a data-sharing
7486 // attribute clause on the same construct
7487 if (CurrDir == OMPD_target || CurrDir == OMPD_target_parallel ||
7488 CurrDir == OMPD_target_teams ||
7489 CurrDir == OMPD_target_teams_distribute ||
7490 CurrDir == OMPD_target_teams_distribute_parallel_for ||
7491 CurrDir == OMPD_target_teams_distribute_parallel_for_simd ||
7492 CurrDir == OMPD_target_teams_distribute_simd ||
7493 CurrDir == OMPD_target_parallel_for_simd ||
7494 CurrDir == OMPD_target_parallel_for) {
7495 OpenMPClauseKind ConflictKind;
7496 if (DSAStack->checkMappableExprComponentListsForDecl(
7497 VD, /*CurrentRegionOnly=*/true,
7498 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef,
7499 OpenMPClauseKind WhereFoundClauseKind) -> bool {
7500 ConflictKind = WhereFoundClauseKind;
7503 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
7504 << getOpenMPClauseName(OMPC_private)
7505 << getOpenMPClauseName(ConflictKind)
7506 << getOpenMPDirectiveName(CurrDir);
7507 ReportOriginalDSA(*this, DSAStack, D, DVar);
7512 // OpenMP [2.9.3.3, Restrictions, C/C++, p.1]
7513 // A variable of class type (or array thereof) that appears in a private
7514 // clause requires an accessible, unambiguous default constructor for the
7516 // Generate helper private variable and initialize it with the default
7517 // value. The address of the original variable is replaced by the address of
7518 // the new private variable in CodeGen. This new variable is not added to
7519 // IdResolver, so the code in the OpenMP region uses original variable for
7520 // proper diagnostics.
7521 Type = Type.getUnqualifiedType();
7522 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
7523 D->hasAttrs() ? &D->getAttrs() : nullptr);
7524 ActOnUninitializedDecl(VDPrivate);
7525 if (VDPrivate->isInvalidDecl())
7527 auto VDPrivateRefExpr = buildDeclRefExpr(
7528 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
7530 DeclRefExpr *Ref = nullptr;
7531 if (!VD && !CurContext->isDependentContext())
7532 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
7533 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_private, Ref);
7534 Vars.push_back((VD || CurContext->isDependentContext())
7535 ? RefExpr->IgnoreParens()
7537 PrivateCopies.push_back(VDPrivateRefExpr);
7543 return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
7548 class DiagsUninitializedSeveretyRAII {
7550 DiagnosticsEngine &Diags;
7551 SourceLocation SavedLoc;
7555 DiagsUninitializedSeveretyRAII(DiagnosticsEngine &Diags, SourceLocation Loc,
7557 : Diags(Diags), SavedLoc(Loc), IsIgnored(IsIgnored) {
7559 Diags.setSeverity(/*Diag*/ diag::warn_uninit_self_reference_in_init,
7560 /*Map*/ diag::Severity::Ignored, Loc);
7563 ~DiagsUninitializedSeveretyRAII() {
7565 Diags.popMappings(SavedLoc);
7570 OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
7571 SourceLocation StartLoc,
7572 SourceLocation LParenLoc,
7573 SourceLocation EndLoc) {
7574 SmallVector<Expr *, 8> Vars;
7575 SmallVector<Expr *, 8> PrivateCopies;
7576 SmallVector<Expr *, 8> Inits;
7577 SmallVector<Decl *, 4> ExprCaptures;
7578 bool IsImplicitClause =
7579 StartLoc.isInvalid() && LParenLoc.isInvalid() && EndLoc.isInvalid();
7580 auto ImplicitClauseLoc = DSAStack->getConstructLoc();
7582 for (auto &RefExpr : VarList) {
7583 assert(RefExpr && "NULL expr in OpenMP firstprivate clause.");
7584 SourceLocation ELoc;
7586 Expr *SimpleRefExpr = RefExpr;
7587 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
7589 // It will be analyzed later.
7590 Vars.push_back(RefExpr);
7591 PrivateCopies.push_back(nullptr);
7592 Inits.push_back(nullptr);
7594 ValueDecl *D = Res.first;
7598 ELoc = IsImplicitClause ? ImplicitClauseLoc : ELoc;
7599 QualType Type = D->getType();
7600 auto *VD = dyn_cast<VarDecl>(D);
7602 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
7603 // A variable that appears in a private clause must not have an incomplete
7604 // type or a reference type.
7605 if (RequireCompleteType(ELoc, Type,
7606 diag::err_omp_firstprivate_incomplete_type))
7608 Type = Type.getNonReferenceType();
7610 // OpenMP [2.9.3.4, Restrictions, C/C++, p.1]
7611 // A variable of class type (or array thereof) that appears in a private
7612 // clause requires an accessible, unambiguous copy constructor for the
7614 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
7616 // If an implicit firstprivate variable found it was checked already.
7617 DSAStackTy::DSAVarData TopDVar;
7618 if (!IsImplicitClause) {
7619 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
7621 bool IsConstant = ElemType.isConstant(Context);
7622 // OpenMP [2.4.13, Data-sharing Attribute Clauses]
7623 // A list item that specifies a given variable may not appear in more
7624 // than one clause on the same directive, except that a variable may be
7625 // specified in both firstprivate and lastprivate clauses.
7626 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_firstprivate &&
7627 DVar.CKind != OMPC_lastprivate && DVar.RefExpr) {
7628 Diag(ELoc, diag::err_omp_wrong_dsa)
7629 << getOpenMPClauseName(DVar.CKind)
7630 << getOpenMPClauseName(OMPC_firstprivate);
7631 ReportOriginalDSA(*this, DSAStack, D, DVar);
7635 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
7637 // Variables with the predetermined data-sharing attributes may not be
7638 // listed in data-sharing attributes clauses, except for the cases
7639 // listed below. For these exceptions only, listing a predetermined
7640 // variable in a data-sharing attribute clause is allowed and overrides
7641 // the variable's predetermined data-sharing attributes.
7642 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
7643 // in a Construct, C/C++, p.2]
7644 // Variables with const-qualified type having no mutable member may be
7645 // listed in a firstprivate clause, even if they are static data members.
7646 if (!(IsConstant || (VD && VD->isStaticDataMember())) && !DVar.RefExpr &&
7647 DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared) {
7648 Diag(ELoc, diag::err_omp_wrong_dsa)
7649 << getOpenMPClauseName(DVar.CKind)
7650 << getOpenMPClauseName(OMPC_firstprivate);
7651 ReportOriginalDSA(*this, DSAStack, D, DVar);
7655 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
7656 // OpenMP [2.9.3.4, Restrictions, p.2]
7657 // A list item that is private within a parallel region must not appear
7658 // in a firstprivate clause on a worksharing construct if any of the
7659 // worksharing regions arising from the worksharing construct ever bind
7660 // to any of the parallel regions arising from the parallel construct.
7661 if (isOpenMPWorksharingDirective(CurrDir) &&
7662 !isOpenMPParallelDirective(CurrDir) &&
7663 !isOpenMPTeamsDirective(CurrDir)) {
7664 DVar = DSAStack->getImplicitDSA(D, true);
7665 if (DVar.CKind != OMPC_shared &&
7666 (isOpenMPParallelDirective(DVar.DKind) ||
7667 DVar.DKind == OMPD_unknown)) {
7668 Diag(ELoc, diag::err_omp_required_access)
7669 << getOpenMPClauseName(OMPC_firstprivate)
7670 << getOpenMPClauseName(OMPC_shared);
7671 ReportOriginalDSA(*this, DSAStack, D, DVar);
7675 // OpenMP [2.9.3.4, Restrictions, p.3]
7676 // A list item that appears in a reduction clause of a parallel construct
7677 // must not appear in a firstprivate clause on a worksharing or task
7678 // construct if any of the worksharing or task regions arising from the
7679 // worksharing or task construct ever bind to any of the parallel regions
7680 // arising from the parallel construct.
7681 // OpenMP [2.9.3.4, Restrictions, p.4]
7682 // A list item that appears in a reduction clause in worksharing
7683 // construct must not appear in a firstprivate clause in a task construct
7684 // encountered during execution of any of the worksharing regions arising
7685 // from the worksharing construct.
7686 if (isOpenMPTaskingDirective(CurrDir)) {
7687 DVar = DSAStack->hasInnermostDSA(
7688 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
7689 [](OpenMPDirectiveKind K) -> bool {
7690 return isOpenMPParallelDirective(K) ||
7691 isOpenMPWorksharingDirective(K);
7694 if (DVar.CKind == OMPC_reduction &&
7695 (isOpenMPParallelDirective(DVar.DKind) ||
7696 isOpenMPWorksharingDirective(DVar.DKind))) {
7697 Diag(ELoc, diag::err_omp_parallel_reduction_in_task_firstprivate)
7698 << getOpenMPDirectiveName(DVar.DKind);
7699 ReportOriginalDSA(*this, DSAStack, D, DVar);
7704 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
7705 // A list item that is private within a teams region must not appear in a
7706 // firstprivate clause on a distribute construct if any of the distribute
7707 // regions arising from the distribute construct ever bind to any of the
7708 // teams regions arising from the teams construct.
7709 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
7710 // A list item that appears in a reduction clause of a teams construct
7711 // must not appear in a firstprivate clause on a distribute construct if
7712 // any of the distribute regions arising from the distribute construct
7713 // ever bind to any of the teams regions arising from the teams construct.
7714 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
7715 // A list item may appear in a firstprivate or lastprivate clause but not
7717 if (CurrDir == OMPD_distribute) {
7718 DVar = DSAStack->hasInnermostDSA(
7719 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_private; },
7720 [](OpenMPDirectiveKind K) -> bool {
7721 return isOpenMPTeamsDirective(K);
7724 if (DVar.CKind == OMPC_private && isOpenMPTeamsDirective(DVar.DKind)) {
7725 Diag(ELoc, diag::err_omp_firstprivate_distribute_private_teams);
7726 ReportOriginalDSA(*this, DSAStack, D, DVar);
7729 DVar = DSAStack->hasInnermostDSA(
7730 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
7731 [](OpenMPDirectiveKind K) -> bool {
7732 return isOpenMPTeamsDirective(K);
7735 if (DVar.CKind == OMPC_reduction &&
7736 isOpenMPTeamsDirective(DVar.DKind)) {
7737 Diag(ELoc, diag::err_omp_firstprivate_distribute_in_teams_reduction);
7738 ReportOriginalDSA(*this, DSAStack, D, DVar);
7741 DVar = DSAStack->getTopDSA(D, false);
7742 if (DVar.CKind == OMPC_lastprivate) {
7743 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
7744 ReportOriginalDSA(*this, DSAStack, D, DVar);
7748 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
7749 // A list item cannot appear in both a map clause and a data-sharing
7750 // attribute clause on the same construct
7751 if (CurrDir == OMPD_target || CurrDir == OMPD_target_parallel ||
7752 CurrDir == OMPD_target_teams ||
7753 CurrDir == OMPD_target_teams_distribute ||
7754 CurrDir == OMPD_target_teams_distribute_parallel_for ||
7755 CurrDir == OMPD_target_teams_distribute_parallel_for_simd ||
7756 CurrDir == OMPD_target_teams_distribute_simd ||
7757 CurrDir == OMPD_target_parallel_for_simd ||
7758 CurrDir == OMPD_target_parallel_for) {
7759 OpenMPClauseKind ConflictKind;
7760 if (DSAStack->checkMappableExprComponentListsForDecl(
7761 VD, /*CurrentRegionOnly=*/true,
7762 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef,
7763 OpenMPClauseKind WhereFoundClauseKind) -> bool {
7764 ConflictKind = WhereFoundClauseKind;
7767 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
7768 << getOpenMPClauseName(OMPC_firstprivate)
7769 << getOpenMPClauseName(ConflictKind)
7770 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
7771 ReportOriginalDSA(*this, DSAStack, D, DVar);
7777 // Variably modified types are not supported for tasks.
7778 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
7779 isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) {
7780 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
7781 << getOpenMPClauseName(OMPC_firstprivate) << Type
7782 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
7785 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
7786 Diag(D->getLocation(),
7787 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
7792 Type = Type.getUnqualifiedType();
7793 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
7794 D->hasAttrs() ? &D->getAttrs() : nullptr);
7795 // Generate helper private variable and initialize it with the value of the
7796 // original variable. The address of the original variable is replaced by
7797 // the address of the new private variable in the CodeGen. This new variable
7798 // is not added to IdResolver, so the code in the OpenMP region uses
7799 // original variable for proper diagnostics and variable capturing.
7800 Expr *VDInitRefExpr = nullptr;
7801 // For arrays generate initializer for single element and replace it by the
7802 // original array element in CodeGen.
7803 if (Type->isArrayType()) {
7805 buildVarDecl(*this, RefExpr->getExprLoc(), ElemType, D->getName());
7806 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, ElemType, ELoc);
7807 auto Init = DefaultLvalueConversion(VDInitRefExpr).get();
7808 ElemType = ElemType.getUnqualifiedType();
7809 auto *VDInitTemp = buildVarDecl(*this, RefExpr->getExprLoc(), ElemType,
7810 ".firstprivate.temp");
7811 InitializedEntity Entity =
7812 InitializedEntity::InitializeVariable(VDInitTemp);
7813 InitializationKind Kind = InitializationKind::CreateCopy(ELoc, ELoc);
7815 InitializationSequence InitSeq(*this, Entity, Kind, Init);
7816 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Init);
7817 if (Result.isInvalid())
7818 VDPrivate->setInvalidDecl();
7820 VDPrivate->setInit(Result.getAs<Expr>());
7821 // Remove temp variable declaration.
7822 Context.Deallocate(VDInitTemp);
7824 auto *VDInit = buildVarDecl(*this, RefExpr->getExprLoc(), Type,
7825 ".firstprivate.temp");
7826 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(),
7827 RefExpr->getExprLoc());
7828 AddInitializerToDecl(VDPrivate,
7829 DefaultLvalueConversion(VDInitRefExpr).get(),
7830 /*DirectInit=*/false);
7832 if (VDPrivate->isInvalidDecl()) {
7833 if (IsImplicitClause) {
7834 Diag(RefExpr->getExprLoc(),
7835 diag::note_omp_task_predetermined_firstprivate_here);
7839 CurContext->addDecl(VDPrivate);
7840 auto VDPrivateRefExpr = buildDeclRefExpr(
7841 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(),
7842 RefExpr->getExprLoc());
7843 DeclRefExpr *Ref = nullptr;
7844 if (!VD && !CurContext->isDependentContext()) {
7845 if (TopDVar.CKind == OMPC_lastprivate)
7846 Ref = TopDVar.PrivateCopy;
7848 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
7849 if (!IsOpenMPCapturedDecl(D))
7850 ExprCaptures.push_back(Ref->getDecl());
7853 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref);
7854 Vars.push_back((VD || CurContext->isDependentContext())
7855 ? RefExpr->IgnoreParens()
7857 PrivateCopies.push_back(VDPrivateRefExpr);
7858 Inits.push_back(VDInitRefExpr);
7864 return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
7865 Vars, PrivateCopies, Inits,
7866 buildPreInits(Context, ExprCaptures));
7869 OMPClause *Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
7870 SourceLocation StartLoc,
7871 SourceLocation LParenLoc,
7872 SourceLocation EndLoc) {
7873 SmallVector<Expr *, 8> Vars;
7874 SmallVector<Expr *, 8> SrcExprs;
7875 SmallVector<Expr *, 8> DstExprs;
7876 SmallVector<Expr *, 8> AssignmentOps;
7877 SmallVector<Decl *, 4> ExprCaptures;
7878 SmallVector<Expr *, 4> ExprPostUpdates;
7879 for (auto &RefExpr : VarList) {
7880 assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
7881 SourceLocation ELoc;
7883 Expr *SimpleRefExpr = RefExpr;
7884 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
7886 // It will be analyzed later.
7887 Vars.push_back(RefExpr);
7888 SrcExprs.push_back(nullptr);
7889 DstExprs.push_back(nullptr);
7890 AssignmentOps.push_back(nullptr);
7892 ValueDecl *D = Res.first;
7896 QualType Type = D->getType();
7897 auto *VD = dyn_cast<VarDecl>(D);
7899 // OpenMP [2.14.3.5, Restrictions, C/C++, p.2]
7900 // A variable that appears in a lastprivate clause must not have an
7901 // incomplete type or a reference type.
7902 if (RequireCompleteType(ELoc, Type,
7903 diag::err_omp_lastprivate_incomplete_type))
7905 Type = Type.getNonReferenceType();
7907 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
7909 // Variables with the predetermined data-sharing attributes may not be
7910 // listed in data-sharing attributes clauses, except for the cases
7912 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
7913 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_lastprivate &&
7914 DVar.CKind != OMPC_firstprivate &&
7915 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
7916 Diag(ELoc, diag::err_omp_wrong_dsa)
7917 << getOpenMPClauseName(DVar.CKind)
7918 << getOpenMPClauseName(OMPC_lastprivate);
7919 ReportOriginalDSA(*this, DSAStack, D, DVar);
7923 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
7924 // OpenMP [2.14.3.5, Restrictions, p.2]
7925 // A list item that is private within a parallel region, or that appears in
7926 // the reduction clause of a parallel construct, must not appear in a
7927 // lastprivate clause on a worksharing construct if any of the corresponding
7928 // worksharing regions ever binds to any of the corresponding parallel
7930 DSAStackTy::DSAVarData TopDVar = DVar;
7931 if (isOpenMPWorksharingDirective(CurrDir) &&
7932 !isOpenMPParallelDirective(CurrDir) &&
7933 !isOpenMPTeamsDirective(CurrDir)) {
7934 DVar = DSAStack->getImplicitDSA(D, true);
7935 if (DVar.CKind != OMPC_shared) {
7936 Diag(ELoc, diag::err_omp_required_access)
7937 << getOpenMPClauseName(OMPC_lastprivate)
7938 << getOpenMPClauseName(OMPC_shared);
7939 ReportOriginalDSA(*this, DSAStack, D, DVar);
7944 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
7945 // A list item may appear in a firstprivate or lastprivate clause but not
7947 if (CurrDir == OMPD_distribute) {
7948 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
7949 if (DVar.CKind == OMPC_firstprivate) {
7950 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
7951 ReportOriginalDSA(*this, DSAStack, D, DVar);
7956 // OpenMP [2.14.3.5, Restrictions, C++, p.1,2]
7957 // A variable of class type (or array thereof) that appears in a
7958 // lastprivate clause requires an accessible, unambiguous default
7959 // constructor for the class type, unless the list item is also specified
7960 // in a firstprivate clause.
7961 // A variable of class type (or array thereof) that appears in a
7962 // lastprivate clause requires an accessible, unambiguous copy assignment
7963 // operator for the class type.
7964 Type = Context.getBaseElementType(Type).getNonReferenceType();
7965 auto *SrcVD = buildVarDecl(*this, ERange.getBegin(),
7966 Type.getUnqualifiedType(), ".lastprivate.src",
7967 D->hasAttrs() ? &D->getAttrs() : nullptr);
7968 auto *PseudoSrcExpr =
7969 buildDeclRefExpr(*this, SrcVD, Type.getUnqualifiedType(), ELoc);
7971 buildVarDecl(*this, ERange.getBegin(), Type, ".lastprivate.dst",
7972 D->hasAttrs() ? &D->getAttrs() : nullptr);
7973 auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc);
7974 // For arrays generate assignment operation for single element and replace
7975 // it by the original array element in CodeGen.
7976 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, ELoc, BO_Assign,
7977 PseudoDstExpr, PseudoSrcExpr);
7978 if (AssignmentOp.isInvalid())
7980 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
7981 /*DiscardedValue=*/true);
7982 if (AssignmentOp.isInvalid())
7985 DeclRefExpr *Ref = nullptr;
7986 if (!VD && !CurContext->isDependentContext()) {
7987 if (TopDVar.CKind == OMPC_firstprivate)
7988 Ref = TopDVar.PrivateCopy;
7990 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
7991 if (!IsOpenMPCapturedDecl(D))
7992 ExprCaptures.push_back(Ref->getDecl());
7994 if (TopDVar.CKind == OMPC_firstprivate ||
7995 (!IsOpenMPCapturedDecl(D) &&
7996 Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>())) {
7997 ExprResult RefRes = DefaultLvalueConversion(Ref);
7998 if (!RefRes.isUsable())
8000 ExprResult PostUpdateRes =
8001 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, SimpleRefExpr,
8003 if (!PostUpdateRes.isUsable())
8005 ExprPostUpdates.push_back(
8006 IgnoredValueConversions(PostUpdateRes.get()).get());
8009 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_lastprivate, Ref);
8010 Vars.push_back((VD || CurContext->isDependentContext())
8011 ? RefExpr->IgnoreParens()
8013 SrcExprs.push_back(PseudoSrcExpr);
8014 DstExprs.push_back(PseudoDstExpr);
8015 AssignmentOps.push_back(AssignmentOp.get());
8021 return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8022 Vars, SrcExprs, DstExprs, AssignmentOps,
8023 buildPreInits(Context, ExprCaptures),
8024 buildPostUpdate(*this, ExprPostUpdates));
8027 OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
8028 SourceLocation StartLoc,
8029 SourceLocation LParenLoc,
8030 SourceLocation EndLoc) {
8031 SmallVector<Expr *, 8> Vars;
8032 for (auto &RefExpr : VarList) {
8033 assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8034 SourceLocation ELoc;
8036 Expr *SimpleRefExpr = RefExpr;
8037 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8039 // It will be analyzed later.
8040 Vars.push_back(RefExpr);
8042 ValueDecl *D = Res.first;
8046 auto *VD = dyn_cast<VarDecl>(D);
8047 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8049 // Variables with the predetermined data-sharing attributes may not be
8050 // listed in data-sharing attributes clauses, except for the cases
8051 // listed below. For these exceptions only, listing a predetermined
8052 // variable in a data-sharing attribute clause is allowed and overrides
8053 // the variable's predetermined data-sharing attributes.
8054 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8055 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared &&
8057 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8058 << getOpenMPClauseName(OMPC_shared);
8059 ReportOriginalDSA(*this, DSAStack, D, DVar);
8063 DeclRefExpr *Ref = nullptr;
8064 if (!VD && IsOpenMPCapturedDecl(D) && !CurContext->isDependentContext())
8065 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8066 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_shared, Ref);
8067 Vars.push_back((VD || !Ref || CurContext->isDependentContext())
8068 ? RefExpr->IgnoreParens()
8075 return OMPSharedClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars);
8079 class DSARefChecker : public StmtVisitor<DSARefChecker, bool> {
8083 bool VisitDeclRefExpr(DeclRefExpr *E) {
8084 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) {
8085 DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, false);
8086 if (DVar.CKind == OMPC_shared && !DVar.RefExpr)
8088 if (DVar.CKind != OMPC_unknown)
8090 DSAStackTy::DSAVarData DVarPrivate = Stack->hasDSA(
8091 VD, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
8093 if (DVarPrivate.CKind != OMPC_unknown)
8099 bool VisitStmt(Stmt *S) {
8100 for (auto Child : S->children()) {
8101 if (Child && Visit(Child))
8106 explicit DSARefChecker(DSAStackTy *S) : Stack(S) {}
8111 // Transform MemberExpression for specified FieldDecl of current class to
8112 // DeclRefExpr to specified OMPCapturedExprDecl.
8113 class TransformExprToCaptures : public TreeTransform<TransformExprToCaptures> {
8114 typedef TreeTransform<TransformExprToCaptures> BaseTransform;
8116 DeclRefExpr *CapturedExpr;
8119 TransformExprToCaptures(Sema &SemaRef, ValueDecl *FieldDecl)
8120 : BaseTransform(SemaRef), Field(FieldDecl), CapturedExpr(nullptr) {}
8122 ExprResult TransformMemberExpr(MemberExpr *E) {
8123 if (isa<CXXThisExpr>(E->getBase()->IgnoreParenImpCasts()) &&
8124 E->getMemberDecl() == Field) {
8125 CapturedExpr = buildCapture(SemaRef, Field, E, /*WithInit=*/false);
8126 return CapturedExpr;
8128 return BaseTransform::TransformMemberExpr(E);
8130 DeclRefExpr *getCapturedExpr() { return CapturedExpr; }
8134 template <typename T>
8135 static T filterLookupForUDR(SmallVectorImpl<UnresolvedSet<8>> &Lookups,
8136 const llvm::function_ref<T(ValueDecl *)> &Gen) {
8137 for (auto &Set : Lookups) {
8138 for (auto *D : Set) {
8139 if (auto Res = Gen(cast<ValueDecl>(D)))
8147 buildDeclareReductionRef(Sema &SemaRef, SourceLocation Loc, SourceRange Range,
8148 Scope *S, CXXScopeSpec &ReductionIdScopeSpec,
8149 const DeclarationNameInfo &ReductionId, QualType Ty,
8150 CXXCastPath &BasePath, Expr *UnresolvedReduction) {
8151 if (ReductionIdScopeSpec.isInvalid())
8153 SmallVector<UnresolvedSet<8>, 4> Lookups;
8155 LookupResult Lookup(SemaRef, ReductionId, Sema::LookupOMPReductionName);
8156 Lookup.suppressDiagnostics();
8157 while (S && SemaRef.LookupParsedName(Lookup, S, &ReductionIdScopeSpec)) {
8158 auto *D = Lookup.getRepresentativeDecl();
8161 } while (S && !S->isDeclScope(D));
8164 Lookups.push_back(UnresolvedSet<8>());
8165 Lookups.back().append(Lookup.begin(), Lookup.end());
8168 } else if (auto *ULE =
8169 cast_or_null<UnresolvedLookupExpr>(UnresolvedReduction)) {
8170 Lookups.push_back(UnresolvedSet<8>());
8171 Decl *PrevD = nullptr;
8172 for (auto *D : ULE->decls()) {
8174 Lookups.push_back(UnresolvedSet<8>());
8175 else if (auto *DRD = cast<OMPDeclareReductionDecl>(D))
8176 Lookups.back().addDecl(DRD);
8180 if (Ty->isDependentType() || Ty->isInstantiationDependentType() ||
8181 Ty->containsUnexpandedParameterPack() ||
8182 filterLookupForUDR<bool>(Lookups, [](ValueDecl *D) -> bool {
8183 return !D->isInvalidDecl() &&
8184 (D->getType()->isDependentType() ||
8185 D->getType()->isInstantiationDependentType() ||
8186 D->getType()->containsUnexpandedParameterPack());
8188 UnresolvedSet<8> ResSet;
8189 for (auto &Set : Lookups) {
8190 ResSet.append(Set.begin(), Set.end());
8191 // The last item marks the end of all declarations at the specified scope.
8192 ResSet.addDecl(Set[Set.size() - 1]);
8194 return UnresolvedLookupExpr::Create(
8195 SemaRef.Context, /*NamingClass=*/nullptr,
8196 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), ReductionId,
8197 /*ADL=*/true, /*Overloaded=*/true, ResSet.begin(), ResSet.end());
8199 if (auto *VD = filterLookupForUDR<ValueDecl *>(
8200 Lookups, [&SemaRef, Ty](ValueDecl *D) -> ValueDecl * {
8201 if (!D->isInvalidDecl() &&
8202 SemaRef.Context.hasSameType(D->getType(), Ty))
8206 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8207 if (auto *VD = filterLookupForUDR<ValueDecl *>(
8208 Lookups, [&SemaRef, Ty, Loc](ValueDecl *D) -> ValueDecl * {
8209 if (!D->isInvalidDecl() &&
8210 SemaRef.IsDerivedFrom(Loc, Ty, D->getType()) &&
8211 !Ty.isMoreQualifiedThan(D->getType()))
8215 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
8216 /*DetectVirtual=*/false);
8217 if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) {
8218 if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType(
8219 VD->getType().getUnqualifiedType()))) {
8220 if (SemaRef.CheckBaseClassAccess(Loc, VD->getType(), Ty, Paths.front(),
8222 Sema::AR_inaccessible) {
8223 SemaRef.BuildBasePathArray(Paths, BasePath);
8224 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8229 if (ReductionIdScopeSpec.isSet()) {
8230 SemaRef.Diag(Loc, diag::err_omp_not_resolved_reduction_identifier) << Range;
8236 OMPClause *Sema::ActOnOpenMPReductionClause(
8237 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
8238 SourceLocation ColonLoc, SourceLocation EndLoc,
8239 CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId,
8240 ArrayRef<Expr *> UnresolvedReductions) {
8241 auto DN = ReductionId.getName();
8242 auto OOK = DN.getCXXOverloadedOperator();
8243 BinaryOperatorKind BOK = BO_Comma;
8245 // OpenMP [2.14.3.6, reduction clause]
8247 // reduction-identifier is either an identifier or one of the following
8248 // operators: +, -, *, &, |, ^, && and ||
8250 // reduction-identifier is either an id-expression or one of the following
8251 // operators: +, -, *, &, |, ^, && and ||
8252 // FIXME: Only 'min' and 'max' identifiers are supported for now.
8279 case OO_Array_Delete:
8288 case OO_GreaterEqual:
8293 case OO_PercentEqual:
8298 case OO_GreaterGreater:
8299 case OO_LessLessEqual:
8300 case OO_GreaterGreaterEqual:
8302 case OO_ExclaimEqual:
8310 case OO_Conditional:
8312 case NUM_OVERLOADED_OPERATORS:
8313 llvm_unreachable("Unexpected reduction identifier");
8315 if (auto II = DN.getAsIdentifierInfo()) {
8316 if (II->isStr("max"))
8318 else if (II->isStr("min"))
8323 SourceRange ReductionIdRange;
8324 if (ReductionIdScopeSpec.isValid())
8325 ReductionIdRange.setBegin(ReductionIdScopeSpec.getBeginLoc());
8326 ReductionIdRange.setEnd(ReductionId.getEndLoc());
8328 SmallVector<Expr *, 8> Vars;
8329 SmallVector<Expr *, 8> Privates;
8330 SmallVector<Expr *, 8> LHSs;
8331 SmallVector<Expr *, 8> RHSs;
8332 SmallVector<Expr *, 8> ReductionOps;
8333 SmallVector<Decl *, 4> ExprCaptures;
8334 SmallVector<Expr *, 4> ExprPostUpdates;
8335 auto IR = UnresolvedReductions.begin(), ER = UnresolvedReductions.end();
8336 bool FirstIter = true;
8337 for (auto RefExpr : VarList) {
8338 assert(RefExpr && "nullptr expr in OpenMP reduction clause.");
8339 // OpenMP [2.1, C/C++]
8340 // A list item is a variable or array section, subject to the restrictions
8341 // specified in Section 2.4 on page 42 and in each of the sections
8342 // describing clauses and directives for which a list appears.
8343 // OpenMP [2.14.3.3, Restrictions, p.1]
8344 // A variable that is part of another variable (as an array or
8345 // structure element) cannot appear in a private clause.
8346 if (!FirstIter && IR != ER)
8349 SourceLocation ELoc;
8351 Expr *SimpleRefExpr = RefExpr;
8352 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
8353 /*AllowArraySection=*/true);
8355 // It will be analyzed later.
8356 Vars.push_back(RefExpr);
8357 Privates.push_back(nullptr);
8358 LHSs.push_back(nullptr);
8359 RHSs.push_back(nullptr);
8360 // Try to find 'declare reduction' corresponding construct before using
8361 // builtin/overloaded operators.
8362 QualType Type = Context.DependentTy;
8363 CXXCastPath BasePath;
8364 ExprResult DeclareReductionRef = buildDeclareReductionRef(
8365 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
8366 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
8367 if (CurContext->isDependentContext() &&
8368 (DeclareReductionRef.isUnset() ||
8369 isa<UnresolvedLookupExpr>(DeclareReductionRef.get())))
8370 ReductionOps.push_back(DeclareReductionRef.get());
8372 ReductionOps.push_back(nullptr);
8374 ValueDecl *D = Res.first;
8379 auto *ASE = dyn_cast<ArraySubscriptExpr>(RefExpr->IgnoreParens());
8380 auto *OASE = dyn_cast<OMPArraySectionExpr>(RefExpr->IgnoreParens());
8382 Type = ASE->getType().getNonReferenceType();
8384 auto BaseType = OMPArraySectionExpr::getBaseOriginalType(OASE->getBase());
8385 if (auto *ATy = BaseType->getAsArrayTypeUnsafe())
8386 Type = ATy->getElementType();
8388 Type = BaseType->getPointeeType();
8389 Type = Type.getNonReferenceType();
8391 Type = Context.getBaseElementType(D->getType().getNonReferenceType());
8392 auto *VD = dyn_cast<VarDecl>(D);
8394 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8395 // A variable that appears in a private clause must not have an incomplete
8396 // type or a reference type.
8397 if (RequireCompleteType(ELoc, Type,
8398 diag::err_omp_reduction_incomplete_type))
8400 // OpenMP [2.14.3.6, reduction clause, Restrictions]
8401 // A list item that appears in a reduction clause must not be
8403 if (Type.getNonReferenceType().isConstant(Context)) {
8404 Diag(ELoc, diag::err_omp_const_reduction_list_item)
8405 << getOpenMPClauseName(OMPC_reduction) << Type << ERange;
8406 if (!ASE && !OASE) {
8407 bool IsDecl = !VD ||
8408 VD->isThisDeclarationADefinition(Context) ==
8409 VarDecl::DeclarationOnly;
8410 Diag(D->getLocation(),
8411 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8416 // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]
8417 // If a list-item is a reference type then it must bind to the same object
8418 // for all threads of the team.
8419 if (!ASE && !OASE && VD) {
8420 VarDecl *VDDef = VD->getDefinition();
8421 if (VD->getType()->isReferenceType() && VDDef && VDDef->hasInit()) {
8422 DSARefChecker Check(DSAStack);
8423 if (Check.Visit(VDDef->getInit())) {
8424 Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange;
8425 Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
8431 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
8433 // Variables with the predetermined data-sharing attributes may not be
8434 // listed in data-sharing attributes clauses, except for the cases
8435 // listed below. For these exceptions only, listing a predetermined
8436 // variable in a data-sharing attribute clause is allowed and overrides
8437 // the variable's predetermined data-sharing attributes.
8438 // OpenMP [2.14.3.6, Restrictions, p.3]
8439 // Any number of reduction clauses can be specified on the directive,
8440 // but a list item can appear only once in the reduction clauses for that
8442 DSAStackTy::DSAVarData DVar;
8443 DVar = DSAStack->getTopDSA(D, false);
8444 if (DVar.CKind == OMPC_reduction) {
8445 Diag(ELoc, diag::err_omp_once_referenced)
8446 << getOpenMPClauseName(OMPC_reduction);
8448 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);
8449 } else if (DVar.CKind != OMPC_unknown) {
8450 Diag(ELoc, diag::err_omp_wrong_dsa)
8451 << getOpenMPClauseName(DVar.CKind)
8452 << getOpenMPClauseName(OMPC_reduction);
8453 ReportOriginalDSA(*this, DSAStack, D, DVar);
8457 // OpenMP [2.14.3.6, Restrictions, p.1]
8458 // A list item that appears in a reduction clause of a worksharing
8459 // construct must be shared in the parallel regions to which any of the
8460 // worksharing regions arising from the worksharing construct bind.
8461 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8462 if (isOpenMPWorksharingDirective(CurrDir) &&
8463 !isOpenMPParallelDirective(CurrDir) &&
8464 !isOpenMPTeamsDirective(CurrDir)) {
8465 DVar = DSAStack->getImplicitDSA(D, true);
8466 if (DVar.CKind != OMPC_shared) {
8467 Diag(ELoc, diag::err_omp_required_access)
8468 << getOpenMPClauseName(OMPC_reduction)
8469 << getOpenMPClauseName(OMPC_shared);
8470 ReportOriginalDSA(*this, DSAStack, D, DVar);
8475 // Try to find 'declare reduction' corresponding construct before using
8476 // builtin/overloaded operators.
8477 CXXCastPath BasePath;
8478 ExprResult DeclareReductionRef = buildDeclareReductionRef(
8479 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
8480 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
8481 if (DeclareReductionRef.isInvalid())
8483 if (CurContext->isDependentContext() &&
8484 (DeclareReductionRef.isUnset() ||
8485 isa<UnresolvedLookupExpr>(DeclareReductionRef.get()))) {
8486 Vars.push_back(RefExpr);
8487 Privates.push_back(nullptr);
8488 LHSs.push_back(nullptr);
8489 RHSs.push_back(nullptr);
8490 ReductionOps.push_back(DeclareReductionRef.get());
8493 if (BOK == BO_Comma && DeclareReductionRef.isUnset()) {
8494 // Not allowed reduction identifier is found.
8495 Diag(ReductionId.getLocStart(),
8496 diag::err_omp_unknown_reduction_identifier)
8497 << Type << ReductionIdRange;
8501 // OpenMP [2.14.3.6, reduction clause, Restrictions]
8502 // The type of a list item that appears in a reduction clause must be valid
8503 // for the reduction-identifier. For a max or min reduction in C, the type
8504 // of the list item must be an allowed arithmetic data type: char, int,
8505 // float, double, or _Bool, possibly modified with long, short, signed, or
8506 // unsigned. For a max or min reduction in C++, the type of the list item
8507 // must be an allowed arithmetic data type: char, wchar_t, int, float,
8508 // double, or bool, possibly modified with long, short, signed, or unsigned.
8509 if (DeclareReductionRef.isUnset()) {
8510 if ((BOK == BO_GT || BOK == BO_LT) &&
8511 !(Type->isScalarType() ||
8512 (getLangOpts().CPlusPlus && Type->isArithmeticType()))) {
8513 Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg)
8514 << getLangOpts().CPlusPlus;
8515 if (!ASE && !OASE) {
8516 bool IsDecl = !VD ||
8517 VD->isThisDeclarationADefinition(Context) ==
8518 VarDecl::DeclarationOnly;
8519 Diag(D->getLocation(),
8520 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8525 if ((BOK == BO_OrAssign || BOK == BO_AndAssign || BOK == BO_XorAssign) &&
8526 !getLangOpts().CPlusPlus && Type->isFloatingType()) {
8527 Diag(ELoc, diag::err_omp_clause_floating_type_arg);
8528 if (!ASE && !OASE) {
8529 bool IsDecl = !VD ||
8530 VD->isThisDeclarationADefinition(Context) ==
8531 VarDecl::DeclarationOnly;
8532 Diag(D->getLocation(),
8533 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8540 Type = Type.getNonLValueExprType(Context).getUnqualifiedType();
8541 auto *LHSVD = buildVarDecl(*this, ELoc, Type, ".reduction.lhs",
8542 D->hasAttrs() ? &D->getAttrs() : nullptr);
8543 auto *RHSVD = buildVarDecl(*this, ELoc, Type, D->getName(),
8544 D->hasAttrs() ? &D->getAttrs() : nullptr);
8545 auto PrivateTy = Type;
8548 D->getType().getNonReferenceType()->isVariablyModifiedType())) {
8549 // For arrays/array sections only:
8550 // Create pseudo array type for private copy. The size for this array will
8551 // be generated during codegen.
8552 // For array subscripts or single variables Private Ty is the same as Type
8553 // (type of the variable or single array element).
8554 PrivateTy = Context.getVariableArrayType(
8555 Type, new (Context) OpaqueValueExpr(SourceLocation(),
8556 Context.getSizeType(), VK_RValue),
8557 ArrayType::Normal, /*IndexTypeQuals=*/0, SourceRange());
8558 } else if (!ASE && !OASE &&
8559 Context.getAsArrayType(D->getType().getNonReferenceType()))
8560 PrivateTy = D->getType().getNonReferenceType();
8562 auto *PrivateVD = buildVarDecl(*this, ELoc, PrivateTy, D->getName(),
8563 D->hasAttrs() ? &D->getAttrs() : nullptr);
8564 // Add initializer for private variable.
8565 Expr *Init = nullptr;
8566 auto *LHSDRE = buildDeclRefExpr(*this, LHSVD, Type, ELoc);
8567 auto *RHSDRE = buildDeclRefExpr(*this, RHSVD, Type, ELoc);
8568 if (DeclareReductionRef.isUsable()) {
8569 auto *DRDRef = DeclareReductionRef.getAs<DeclRefExpr>();
8570 auto *DRD = cast<OMPDeclareReductionDecl>(DRDRef->getDecl());
8571 if (DRD->getInitializer()) {
8573 RHSVD->setInit(DRDRef);
8574 RHSVD->setInitStyle(VarDecl::CallInit);
8582 // '+', '-', '^', '|', '||' reduction ops - initializer is '0'.
8583 if (Type->isScalarType() || Type->isAnyComplexType())
8584 Init = ActOnIntegerConstant(ELoc, /*Val=*/0).get();
8588 if (Type->isScalarType() || Type->isAnyComplexType()) {
8589 // '*' and '&&' reduction ops - initializer is '1'.
8590 Init = ActOnIntegerConstant(ELoc, /*Val=*/1).get();
8594 // '&' reduction op - initializer is '~0'.
8595 QualType OrigType = Type;
8596 if (auto *ComplexTy = OrigType->getAs<ComplexType>())
8597 Type = ComplexTy->getElementType();
8598 if (Type->isRealFloatingType()) {
8599 llvm::APFloat InitValue =
8600 llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type),
8602 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
8604 } else if (Type->isScalarType()) {
8605 auto Size = Context.getTypeSize(Type);
8606 QualType IntTy = Context.getIntTypeForBitwidth(Size, /*Signed=*/0);
8607 llvm::APInt InitValue = llvm::APInt::getAllOnesValue(Size);
8608 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
8610 if (Init && OrigType->isAnyComplexType()) {
8611 // Init = 0xFFFF + 0xFFFFi;
8612 auto *Im = new (Context) ImaginaryLiteral(Init, OrigType);
8613 Init = CreateBuiltinBinOp(ELoc, BO_Add, Init, Im).get();
8620 // 'min' reduction op - initializer is 'Largest representable number in
8621 // the reduction list item type'.
8622 // 'max' reduction op - initializer is 'Least representable number in
8623 // the reduction list item type'.
8624 if (Type->isIntegerType() || Type->isPointerType()) {
8625 bool IsSigned = Type->hasSignedIntegerRepresentation();
8626 auto Size = Context.getTypeSize(Type);
8628 Context.getIntTypeForBitwidth(Size, /*Signed=*/IsSigned);
8629 llvm::APInt InitValue =
8631 ? IsSigned ? llvm::APInt::getSignedMinValue(Size)
8632 : llvm::APInt::getMinValue(Size)
8633 : IsSigned ? llvm::APInt::getSignedMaxValue(Size)
8634 : llvm::APInt::getMaxValue(Size);
8635 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
8636 if (Type->isPointerType()) {
8637 // Cast to pointer type.
8638 auto CastExpr = BuildCStyleCastExpr(
8639 SourceLocation(), Context.getTrivialTypeSourceInfo(Type, ELoc),
8640 SourceLocation(), Init);
8641 if (CastExpr.isInvalid())
8643 Init = CastExpr.get();
8645 } else if (Type->isRealFloatingType()) {
8646 llvm::APFloat InitValue = llvm::APFloat::getLargest(
8647 Context.getFloatTypeSemantics(Type), BOK != BO_LT);
8648 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
8676 llvm_unreachable("Unexpected reduction operation");
8679 if (Init && DeclareReductionRef.isUnset()) {
8680 AddInitializerToDecl(RHSVD, Init, /*DirectInit=*/false);
8682 ActOnUninitializedDecl(RHSVD);
8683 if (RHSVD->isInvalidDecl())
8685 if (!RHSVD->hasInit() && DeclareReductionRef.isUnset()) {
8686 Diag(ELoc, diag::err_omp_reduction_id_not_compatible) << Type
8687 << ReductionIdRange;
8690 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8691 Diag(D->getLocation(),
8692 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8696 // Store initializer for single element in private copy. Will be used during
8698 PrivateVD->setInit(RHSVD->getInit());
8699 PrivateVD->setInitStyle(RHSVD->getInitStyle());
8700 auto *PrivateDRE = buildDeclRefExpr(*this, PrivateVD, PrivateTy, ELoc);
8701 ExprResult ReductionOp;
8702 if (DeclareReductionRef.isUsable()) {
8703 QualType RedTy = DeclareReductionRef.get()->getType();
8704 QualType PtrRedTy = Context.getPointerType(RedTy);
8705 ExprResult LHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, LHSDRE);
8706 ExprResult RHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, RHSDRE);
8707 if (!BasePath.empty()) {
8708 LHS = DefaultLvalueConversion(LHS.get());
8709 RHS = DefaultLvalueConversion(RHS.get());
8710 LHS = ImplicitCastExpr::Create(Context, PtrRedTy,
8711 CK_UncheckedDerivedToBase, LHS.get(),
8712 &BasePath, LHS.get()->getValueKind());
8713 RHS = ImplicitCastExpr::Create(Context, PtrRedTy,
8714 CK_UncheckedDerivedToBase, RHS.get(),
8715 &BasePath, RHS.get()->getValueKind());
8717 FunctionProtoType::ExtProtoInfo EPI;
8718 QualType Params[] = {PtrRedTy, PtrRedTy};
8719 QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
8720 auto *OVE = new (Context) OpaqueValueExpr(
8721 ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
8722 DefaultLvalueConversion(DeclareReductionRef.get()).get());
8723 Expr *Args[] = {LHS.get(), RHS.get()};
8724 ReductionOp = new (Context)
8725 CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
8727 ReductionOp = BuildBinOp(DSAStack->getCurScope(),
8728 ReductionId.getLocStart(), BOK, LHSDRE, RHSDRE);
8729 if (ReductionOp.isUsable()) {
8730 if (BOK != BO_LT && BOK != BO_GT) {
8732 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
8733 BO_Assign, LHSDRE, ReductionOp.get());
8735 auto *ConditionalOp = new (Context) ConditionalOperator(
8736 ReductionOp.get(), SourceLocation(), LHSDRE, SourceLocation(),
8737 RHSDRE, Type, VK_LValue, OK_Ordinary);
8739 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
8740 BO_Assign, LHSDRE, ConditionalOp);
8742 ReductionOp = ActOnFinishFullExpr(ReductionOp.get());
8744 if (ReductionOp.isInvalid())
8748 DeclRefExpr *Ref = nullptr;
8749 Expr *VarsExpr = RefExpr->IgnoreParens();
8750 if (!VD && !CurContext->isDependentContext()) {
8752 TransformExprToCaptures RebuildToCapture(*this, D);
8754 RebuildToCapture.TransformExpr(RefExpr->IgnoreParens()).get();
8755 Ref = RebuildToCapture.getCapturedExpr();
8758 buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8760 if (!IsOpenMPCapturedDecl(D)) {
8761 ExprCaptures.push_back(Ref->getDecl());
8762 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
8763 ExprResult RefRes = DefaultLvalueConversion(Ref);
8764 if (!RefRes.isUsable())
8766 ExprResult PostUpdateRes =
8767 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
8768 SimpleRefExpr, RefRes.get());
8769 if (!PostUpdateRes.isUsable())
8771 ExprPostUpdates.push_back(
8772 IgnoredValueConversions(PostUpdateRes.get()).get());
8776 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_reduction, Ref);
8777 Vars.push_back(VarsExpr);
8778 Privates.push_back(PrivateDRE);
8779 LHSs.push_back(LHSDRE);
8780 RHSs.push_back(RHSDRE);
8781 ReductionOps.push_back(ReductionOp.get());
8787 return OMPReductionClause::Create(
8788 Context, StartLoc, LParenLoc, ColonLoc, EndLoc, Vars,
8789 ReductionIdScopeSpec.getWithLocInContext(Context), ReductionId, Privates,
8790 LHSs, RHSs, ReductionOps, buildPreInits(Context, ExprCaptures),
8791 buildPostUpdate(*this, ExprPostUpdates));
8794 bool Sema::CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
8795 SourceLocation LinLoc) {
8796 if ((!LangOpts.CPlusPlus && LinKind != OMPC_LINEAR_val) ||
8797 LinKind == OMPC_LINEAR_unknown) {
8798 Diag(LinLoc, diag::err_omp_wrong_linear_modifier) << LangOpts.CPlusPlus;
8804 bool Sema::CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc,
8805 OpenMPLinearClauseKind LinKind,
8807 auto *VD = dyn_cast_or_null<VarDecl>(D);
8808 // A variable must not have an incomplete type or a reference type.
8809 if (RequireCompleteType(ELoc, Type, diag::err_omp_linear_incomplete_type))
8811 if ((LinKind == OMPC_LINEAR_uval || LinKind == OMPC_LINEAR_ref) &&
8812 !Type->isReferenceType()) {
8813 Diag(ELoc, diag::err_omp_wrong_linear_modifier_non_reference)
8814 << Type << getOpenMPSimpleClauseTypeName(OMPC_linear, LinKind);
8817 Type = Type.getNonReferenceType();
8819 // A list item must not be const-qualified.
8820 if (Type.isConstant(Context)) {
8821 Diag(ELoc, diag::err_omp_const_variable)
8822 << getOpenMPClauseName(OMPC_linear);
8826 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8827 Diag(D->getLocation(),
8828 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8834 // A list item must be of integral or pointer type.
8835 Type = Type.getUnqualifiedType().getCanonicalType();
8836 const auto *Ty = Type.getTypePtrOrNull();
8837 if (!Ty || (!Ty->isDependentType() && !Ty->isIntegralType(Context) &&
8838 !Ty->isPointerType())) {
8839 Diag(ELoc, diag::err_omp_linear_expected_int_or_ptr) << Type;
8843 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8844 Diag(D->getLocation(),
8845 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8853 OMPClause *Sema::ActOnOpenMPLinearClause(
8854 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
8855 SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind,
8856 SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
8857 SmallVector<Expr *, 8> Vars;
8858 SmallVector<Expr *, 8> Privates;
8859 SmallVector<Expr *, 8> Inits;
8860 SmallVector<Decl *, 4> ExprCaptures;
8861 SmallVector<Expr *, 4> ExprPostUpdates;
8862 if (CheckOpenMPLinearModifier(LinKind, LinLoc))
8863 LinKind = OMPC_LINEAR_val;
8864 for (auto &RefExpr : VarList) {
8865 assert(RefExpr && "NULL expr in OpenMP linear clause.");
8866 SourceLocation ELoc;
8868 Expr *SimpleRefExpr = RefExpr;
8869 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
8870 /*AllowArraySection=*/false);
8872 // It will be analyzed later.
8873 Vars.push_back(RefExpr);
8874 Privates.push_back(nullptr);
8875 Inits.push_back(nullptr);
8877 ValueDecl *D = Res.first;
8881 QualType Type = D->getType();
8882 auto *VD = dyn_cast<VarDecl>(D);
8884 // OpenMP [2.14.3.7, linear clause]
8885 // A list-item cannot appear in more than one linear clause.
8886 // A list-item that appears in a linear clause cannot appear in any
8887 // other data-sharing attribute clause.
8888 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8890 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8891 << getOpenMPClauseName(OMPC_linear);
8892 ReportOriginalDSA(*this, DSAStack, D, DVar);
8896 if (CheckOpenMPLinearDecl(D, ELoc, LinKind, Type))
8898 Type = Type.getNonReferenceType().getUnqualifiedType().getCanonicalType();
8900 // Build private copy of original var.
8901 auto *Private = buildVarDecl(*this, ELoc, Type, D->getName(),
8902 D->hasAttrs() ? &D->getAttrs() : nullptr);
8903 auto *PrivateRef = buildDeclRefExpr(*this, Private, Type, ELoc);
8904 // Build var to save initial value.
8905 VarDecl *Init = buildVarDecl(*this, ELoc, Type, ".linear.start");
8907 DeclRefExpr *Ref = nullptr;
8908 if (!VD && !CurContext->isDependentContext()) {
8909 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8910 if (!IsOpenMPCapturedDecl(D)) {
8911 ExprCaptures.push_back(Ref->getDecl());
8912 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
8913 ExprResult RefRes = DefaultLvalueConversion(Ref);
8914 if (!RefRes.isUsable())
8916 ExprResult PostUpdateRes =
8917 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
8918 SimpleRefExpr, RefRes.get());
8919 if (!PostUpdateRes.isUsable())
8921 ExprPostUpdates.push_back(
8922 IgnoredValueConversions(PostUpdateRes.get()).get());
8926 if (LinKind == OMPC_LINEAR_uval)
8927 InitExpr = VD ? VD->getInit() : SimpleRefExpr;
8929 InitExpr = VD ? SimpleRefExpr : Ref;
8930 AddInitializerToDecl(Init, DefaultLvalueConversion(InitExpr).get(),
8931 /*DirectInit=*/false);
8932 auto InitRef = buildDeclRefExpr(*this, Init, Type, ELoc);
8934 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_linear, Ref);
8935 Vars.push_back((VD || CurContext->isDependentContext())
8936 ? RefExpr->IgnoreParens()
8938 Privates.push_back(PrivateRef);
8939 Inits.push_back(InitRef);
8945 Expr *StepExpr = Step;
8946 Expr *CalcStepExpr = nullptr;
8947 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
8948 !Step->isInstantiationDependent() &&
8949 !Step->containsUnexpandedParameterPack()) {
8950 SourceLocation StepLoc = Step->getLocStart();
8951 ExprResult Val = PerformOpenMPImplicitIntegerConversion(StepLoc, Step);
8952 if (Val.isInvalid())
8954 StepExpr = Val.get();
8956 // Build var to save the step value.
8958 buildVarDecl(*this, StepLoc, StepExpr->getType(), ".linear.step");
8959 ExprResult SaveRef =
8960 buildDeclRefExpr(*this, SaveVar, StepExpr->getType(), StepLoc);
8961 ExprResult CalcStep =
8962 BuildBinOp(CurScope, StepLoc, BO_Assign, SaveRef.get(), StepExpr);
8963 CalcStep = ActOnFinishFullExpr(CalcStep.get());
8965 // Warn about zero linear step (it would be probably better specified as
8966 // making corresponding variables 'const').
8967 llvm::APSInt Result;
8968 bool IsConstant = StepExpr->isIntegerConstantExpr(Result, Context);
8969 if (IsConstant && !Result.isNegative() && !Result.isStrictlyPositive())
8970 Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0]
8971 << (Vars.size() > 1);
8972 if (!IsConstant && CalcStep.isUsable()) {
8973 // Calculate the step beforehand instead of doing this on each iteration.
8974 // (This is not used if the number of iterations may be kfold-ed).
8975 CalcStepExpr = CalcStep.get();
8979 return OMPLinearClause::Create(Context, StartLoc, LParenLoc, LinKind, LinLoc,
8980 ColonLoc, EndLoc, Vars, Privates, Inits,
8981 StepExpr, CalcStepExpr,
8982 buildPreInits(Context, ExprCaptures),
8983 buildPostUpdate(*this, ExprPostUpdates));
8986 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
8987 Expr *NumIterations, Sema &SemaRef,
8988 Scope *S, DSAStackTy *Stack) {
8989 // Walk the vars and build update/final expressions for the CodeGen.
8990 SmallVector<Expr *, 8> Updates;
8991 SmallVector<Expr *, 8> Finals;
8992 Expr *Step = Clause.getStep();
8993 Expr *CalcStep = Clause.getCalcStep();
8994 // OpenMP [2.14.3.7, linear clause]
8995 // If linear-step is not specified it is assumed to be 1.
8996 if (Step == nullptr)
8997 Step = SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get();
8998 else if (CalcStep) {
8999 Step = cast<BinaryOperator>(CalcStep)->getLHS();
9001 bool HasErrors = false;
9002 auto CurInit = Clause.inits().begin();
9003 auto CurPrivate = Clause.privates().begin();
9004 auto LinKind = Clause.getModifier();
9005 for (auto &RefExpr : Clause.varlists()) {
9006 SourceLocation ELoc;
9008 Expr *SimpleRefExpr = RefExpr;
9009 auto Res = getPrivateItem(SemaRef, SimpleRefExpr, ELoc, ERange,
9010 /*AllowArraySection=*/false);
9011 ValueDecl *D = Res.first;
9012 if (Res.second || !D) {
9013 Updates.push_back(nullptr);
9014 Finals.push_back(nullptr);
9018 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(D)) {
9019 D = cast<MemberExpr>(CED->getInit()->IgnoreParenImpCasts())
9022 auto &&Info = Stack->isLoopControlVariable(D);
9023 Expr *InitExpr = *CurInit;
9025 // Build privatized reference to the current linear var.
9026 auto *DE = cast<DeclRefExpr>(SimpleRefExpr);
9028 if (LinKind == OMPC_LINEAR_uval)
9029 CapturedRef = cast<VarDecl>(DE->getDecl())->getInit();
9032 buildDeclRefExpr(SemaRef, cast<VarDecl>(DE->getDecl()),
9033 DE->getType().getUnqualifiedType(), DE->getExprLoc(),
9034 /*RefersToCapture=*/true);
9036 // Build update: Var = InitExpr + IV * Step
9040 BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), *CurPrivate,
9041 InitExpr, IV, Step, /* Subtract */ false);
9043 Update = *CurPrivate;
9044 Update = SemaRef.ActOnFinishFullExpr(Update.get(), DE->getLocStart(),
9045 /*DiscardedValue=*/true);
9047 // Build final: Var = InitExpr + NumIterations * Step
9050 Final = BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), CapturedRef,
9051 InitExpr, NumIterations, Step,
9052 /* Subtract */ false);
9054 Final = *CurPrivate;
9055 Final = SemaRef.ActOnFinishFullExpr(Final.get(), DE->getLocStart(),
9056 /*DiscardedValue=*/true);
9058 if (!Update.isUsable() || !Final.isUsable()) {
9059 Updates.push_back(nullptr);
9060 Finals.push_back(nullptr);
9063 Updates.push_back(Update.get());
9064 Finals.push_back(Final.get());
9069 Clause.setUpdates(Updates);
9070 Clause.setFinals(Finals);
9074 OMPClause *Sema::ActOnOpenMPAlignedClause(
9075 ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
9076 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9078 SmallVector<Expr *, 8> Vars;
9079 for (auto &RefExpr : VarList) {
9080 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9081 SourceLocation ELoc;
9083 Expr *SimpleRefExpr = RefExpr;
9084 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9085 /*AllowArraySection=*/false);
9087 // It will be analyzed later.
9088 Vars.push_back(RefExpr);
9090 ValueDecl *D = Res.first;
9094 QualType QType = D->getType();
9095 auto *VD = dyn_cast<VarDecl>(D);
9097 // OpenMP [2.8.1, simd construct, Restrictions]
9098 // The type of list items appearing in the aligned clause must be
9099 // array, pointer, reference to array, or reference to pointer.
9100 QType = QType.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9101 const Type *Ty = QType.getTypePtrOrNull();
9102 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
9103 Diag(ELoc, diag::err_omp_aligned_expected_array_or_ptr)
9104 << QType << getLangOpts().CPlusPlus << ERange;
9107 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9108 Diag(D->getLocation(),
9109 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9114 // OpenMP [2.8.1, simd construct, Restrictions]
9115 // A list-item cannot appear in more than one aligned clause.
9116 if (Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) {
9117 Diag(ELoc, diag::err_omp_aligned_twice) << 0 << ERange;
9118 Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa)
9119 << getOpenMPClauseName(OMPC_aligned);
9123 DeclRefExpr *Ref = nullptr;
9124 if (!VD && IsOpenMPCapturedDecl(D))
9125 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
9126 Vars.push_back(DefaultFunctionArrayConversion(
9127 (VD || !Ref) ? RefExpr->IgnoreParens() : Ref)
9131 // OpenMP [2.8.1, simd construct, Description]
9132 // The parameter of the aligned clause, alignment, must be a constant
9133 // positive integer expression.
9134 // If no optional parameter is specified, implementation-defined default
9135 // alignments for SIMD instructions on the target platforms are assumed.
9136 if (Alignment != nullptr) {
9137 ExprResult AlignResult =
9138 VerifyPositiveIntegerConstantInClause(Alignment, OMPC_aligned);
9139 if (AlignResult.isInvalid())
9141 Alignment = AlignResult.get();
9146 return OMPAlignedClause::Create(Context, StartLoc, LParenLoc, ColonLoc,
9147 EndLoc, Vars, Alignment);
9150 OMPClause *Sema::ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
9151 SourceLocation StartLoc,
9152 SourceLocation LParenLoc,
9153 SourceLocation EndLoc) {
9154 SmallVector<Expr *, 8> Vars;
9155 SmallVector<Expr *, 8> SrcExprs;
9156 SmallVector<Expr *, 8> DstExprs;
9157 SmallVector<Expr *, 8> AssignmentOps;
9158 for (auto &RefExpr : VarList) {
9159 assert(RefExpr && "NULL expr in OpenMP copyin clause.");
9160 if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
9161 // It will be analyzed later.
9162 Vars.push_back(RefExpr);
9163 SrcExprs.push_back(nullptr);
9164 DstExprs.push_back(nullptr);
9165 AssignmentOps.push_back(nullptr);
9169 SourceLocation ELoc = RefExpr->getExprLoc();
9170 // OpenMP [2.1, C/C++]
9171 // A list item is a variable name.
9172 // OpenMP [2.14.4.1, Restrictions, p.1]
9173 // A list item that appears in a copyin clause must be threadprivate.
9174 DeclRefExpr *DE = dyn_cast<DeclRefExpr>(RefExpr);
9175 if (!DE || !isa<VarDecl>(DE->getDecl())) {
9176 Diag(ELoc, diag::err_omp_expected_var_name_member_expr)
9177 << 0 << RefExpr->getSourceRange();
9181 Decl *D = DE->getDecl();
9182 VarDecl *VD = cast<VarDecl>(D);
9184 QualType Type = VD->getType();
9185 if (Type->isDependentType() || Type->isInstantiationDependentType()) {
9186 // It will be analyzed later.
9188 SrcExprs.push_back(nullptr);
9189 DstExprs.push_back(nullptr);
9190 AssignmentOps.push_back(nullptr);
9194 // OpenMP [2.14.4.1, Restrictions, C/C++, p.1]
9195 // A list item that appears in a copyin clause must be threadprivate.
9196 if (!DSAStack->isThreadPrivate(VD)) {
9197 Diag(ELoc, diag::err_omp_required_access)
9198 << getOpenMPClauseName(OMPC_copyin)
9199 << getOpenMPDirectiveName(OMPD_threadprivate);
9203 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
9204 // A variable of class type (or array thereof) that appears in a
9205 // copyin clause requires an accessible, unambiguous copy assignment
9206 // operator for the class type.
9207 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
9209 buildVarDecl(*this, DE->getLocStart(), ElemType.getUnqualifiedType(),
9210 ".copyin.src", VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9211 auto *PseudoSrcExpr = buildDeclRefExpr(
9212 *this, SrcVD, ElemType.getUnqualifiedType(), DE->getExprLoc());
9214 buildVarDecl(*this, DE->getLocStart(), ElemType, ".copyin.dst",
9215 VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9216 auto *PseudoDstExpr =
9217 buildDeclRefExpr(*this, DstVD, ElemType, DE->getExprLoc());
9218 // For arrays generate assignment operation for single element and replace
9219 // it by the original array element in CodeGen.
9220 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, DE->getExprLoc(), BO_Assign,
9221 PseudoDstExpr, PseudoSrcExpr);
9222 if (AssignmentOp.isInvalid())
9224 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), DE->getExprLoc(),
9225 /*DiscardedValue=*/true);
9226 if (AssignmentOp.isInvalid())
9229 DSAStack->addDSA(VD, DE, OMPC_copyin);
9231 SrcExprs.push_back(PseudoSrcExpr);
9232 DstExprs.push_back(PseudoDstExpr);
9233 AssignmentOps.push_back(AssignmentOp.get());
9239 return OMPCopyinClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
9240 SrcExprs, DstExprs, AssignmentOps);
9243 OMPClause *Sema::ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
9244 SourceLocation StartLoc,
9245 SourceLocation LParenLoc,
9246 SourceLocation EndLoc) {
9247 SmallVector<Expr *, 8> Vars;
9248 SmallVector<Expr *, 8> SrcExprs;
9249 SmallVector<Expr *, 8> DstExprs;
9250 SmallVector<Expr *, 8> AssignmentOps;
9251 for (auto &RefExpr : VarList) {
9252 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9253 SourceLocation ELoc;
9255 Expr *SimpleRefExpr = RefExpr;
9256 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9257 /*AllowArraySection=*/false);
9259 // It will be analyzed later.
9260 Vars.push_back(RefExpr);
9261 SrcExprs.push_back(nullptr);
9262 DstExprs.push_back(nullptr);
9263 AssignmentOps.push_back(nullptr);
9265 ValueDecl *D = Res.first;
9269 QualType Type = D->getType();
9270 auto *VD = dyn_cast<VarDecl>(D);
9272 // OpenMP [2.14.4.2, Restrictions, p.2]
9273 // A list item that appears in a copyprivate clause may not appear in a
9274 // private or firstprivate clause on the single construct.
9275 if (!VD || !DSAStack->isThreadPrivate(VD)) {
9276 auto DVar = DSAStack->getTopDSA(D, false);
9277 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_copyprivate &&
9279 Diag(ELoc, diag::err_omp_wrong_dsa)
9280 << getOpenMPClauseName(DVar.CKind)
9281 << getOpenMPClauseName(OMPC_copyprivate);
9282 ReportOriginalDSA(*this, DSAStack, D, DVar);
9286 // OpenMP [2.11.4.2, Restrictions, p.1]
9287 // All list items that appear in a copyprivate clause must be either
9288 // threadprivate or private in the enclosing context.
9289 if (DVar.CKind == OMPC_unknown) {
9290 DVar = DSAStack->getImplicitDSA(D, false);
9291 if (DVar.CKind == OMPC_shared) {
9292 Diag(ELoc, diag::err_omp_required_access)
9293 << getOpenMPClauseName(OMPC_copyprivate)
9294 << "threadprivate or private in the enclosing context";
9295 ReportOriginalDSA(*this, DSAStack, D, DVar);
9301 // Variably modified types are not supported.
9302 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType()) {
9303 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
9304 << getOpenMPClauseName(OMPC_copyprivate) << Type
9305 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
9308 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9309 Diag(D->getLocation(),
9310 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9315 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
9316 // A variable of class type (or array thereof) that appears in a
9317 // copyin clause requires an accessible, unambiguous copy assignment
9318 // operator for the class type.
9319 Type = Context.getBaseElementType(Type.getNonReferenceType())
9320 .getUnqualifiedType();
9322 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.src",
9323 D->hasAttrs() ? &D->getAttrs() : nullptr);
9324 auto *PseudoSrcExpr = buildDeclRefExpr(*this, SrcVD, Type, ELoc);
9326 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.dst",
9327 D->hasAttrs() ? &D->getAttrs() : nullptr);
9328 auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc);
9329 auto AssignmentOp = BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9330 PseudoDstExpr, PseudoSrcExpr);
9331 if (AssignmentOp.isInvalid())
9333 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
9334 /*DiscardedValue=*/true);
9335 if (AssignmentOp.isInvalid())
9338 // No need to mark vars as copyprivate, they are already threadprivate or
9339 // implicitly private.
9340 assert(VD || IsOpenMPCapturedDecl(D));
9342 VD ? RefExpr->IgnoreParens()
9343 : buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false));
9344 SrcExprs.push_back(PseudoSrcExpr);
9345 DstExprs.push_back(PseudoDstExpr);
9346 AssignmentOps.push_back(AssignmentOp.get());
9352 return OMPCopyprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
9353 Vars, SrcExprs, DstExprs, AssignmentOps);
9356 OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
9357 SourceLocation StartLoc,
9358 SourceLocation LParenLoc,
9359 SourceLocation EndLoc) {
9360 if (VarList.empty())
9363 return OMPFlushClause::Create(Context, StartLoc, LParenLoc, EndLoc, VarList);
9367 Sema::ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind,
9368 SourceLocation DepLoc, SourceLocation ColonLoc,
9369 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9370 SourceLocation LParenLoc, SourceLocation EndLoc) {
9371 if (DSAStack->getCurrentDirective() == OMPD_ordered &&
9372 DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink) {
9373 Diag(DepLoc, diag::err_omp_unexpected_clause_value)
9374 << "'source' or 'sink'" << getOpenMPClauseName(OMPC_depend);
9377 if (DSAStack->getCurrentDirective() != OMPD_ordered &&
9378 (DepKind == OMPC_DEPEND_unknown || DepKind == OMPC_DEPEND_source ||
9379 DepKind == OMPC_DEPEND_sink)) {
9380 unsigned Except[] = {OMPC_DEPEND_source, OMPC_DEPEND_sink};
9381 Diag(DepLoc, diag::err_omp_unexpected_clause_value)
9382 << getListOfPossibleValues(OMPC_depend, /*First=*/0,
9383 /*Last=*/OMPC_DEPEND_unknown, Except)
9384 << getOpenMPClauseName(OMPC_depend);
9387 SmallVector<Expr *, 8> Vars;
9388 DSAStackTy::OperatorOffsetTy OpsOffs;
9389 llvm::APSInt DepCounter(/*BitWidth=*/32);
9390 llvm::APSInt TotalDepCount(/*BitWidth=*/32);
9391 if (DepKind == OMPC_DEPEND_sink) {
9392 if (auto *OrderedCountExpr = DSAStack->getParentOrderedRegionParam()) {
9393 TotalDepCount = OrderedCountExpr->EvaluateKnownConstInt(Context);
9394 TotalDepCount.setIsUnsigned(/*Val=*/true);
9397 if ((DepKind != OMPC_DEPEND_sink && DepKind != OMPC_DEPEND_source) ||
9398 DSAStack->getParentOrderedRegionParam()) {
9399 for (auto &RefExpr : VarList) {
9400 assert(RefExpr && "NULL expr in OpenMP shared clause.");
9401 if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
9402 // It will be analyzed later.
9403 Vars.push_back(RefExpr);
9407 SourceLocation ELoc = RefExpr->getExprLoc();
9408 auto *SimpleExpr = RefExpr->IgnoreParenCasts();
9409 if (DepKind == OMPC_DEPEND_sink) {
9410 if (DepCounter >= TotalDepCount) {
9411 Diag(ELoc, diag::err_omp_depend_sink_unexpected_expr);
9415 // OpenMP [2.13.9, Summary]
9416 // depend(dependence-type : vec), where dependence-type is:
9417 // 'sink' and where vec is the iteration vector, which has the form:
9418 // x1 [+- d1], x2 [+- d2 ], . . . , xn [+- dn]
9419 // where n is the value specified by the ordered clause in the loop
9420 // directive, xi denotes the loop iteration variable of the i-th nested
9421 // loop associated with the loop directive, and di is a constant
9422 // non-negative integer.
9423 if (CurContext->isDependentContext()) {
9424 // It will be analyzed later.
9425 Vars.push_back(RefExpr);
9428 SimpleExpr = SimpleExpr->IgnoreImplicit();
9429 OverloadedOperatorKind OOK = OO_None;
9430 SourceLocation OOLoc;
9431 Expr *LHS = SimpleExpr;
9432 Expr *RHS = nullptr;
9433 if (auto *BO = dyn_cast<BinaryOperator>(SimpleExpr)) {
9434 OOK = BinaryOperator::getOverloadedOperator(BO->getOpcode());
9435 OOLoc = BO->getOperatorLoc();
9436 LHS = BO->getLHS()->IgnoreParenImpCasts();
9437 RHS = BO->getRHS()->IgnoreParenImpCasts();
9438 } else if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(SimpleExpr)) {
9439 OOK = OCE->getOperator();
9440 OOLoc = OCE->getOperatorLoc();
9441 LHS = OCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
9442 RHS = OCE->getArg(/*Arg=*/1)->IgnoreParenImpCasts();
9443 } else if (auto *MCE = dyn_cast<CXXMemberCallExpr>(SimpleExpr)) {
9444 OOK = MCE->getMethodDecl()
9447 .getCXXOverloadedOperator();
9448 OOLoc = MCE->getCallee()->getExprLoc();
9449 LHS = MCE->getImplicitObjectArgument()->IgnoreParenImpCasts();
9450 RHS = MCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
9452 SourceLocation ELoc;
9454 auto Res = getPrivateItem(*this, LHS, ELoc, ERange,
9455 /*AllowArraySection=*/false);
9457 // It will be analyzed later.
9458 Vars.push_back(RefExpr);
9460 ValueDecl *D = Res.first;
9464 if (OOK != OO_Plus && OOK != OO_Minus && (RHS || OOK != OO_None)) {
9465 Diag(OOLoc, diag::err_omp_depend_sink_expected_plus_minus);
9469 ExprResult RHSRes = VerifyPositiveIntegerConstantInClause(
9470 RHS, OMPC_depend, /*StrictlyPositive=*/false);
9471 if (RHSRes.isInvalid())
9474 if (!CurContext->isDependentContext() &&
9475 DSAStack->getParentOrderedRegionParam() &&
9476 DepCounter != DSAStack->isParentLoopControlVariable(D).first) {
9477 Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration)
9478 << DSAStack->getParentLoopControlVariable(
9479 DepCounter.getZExtValue());
9482 OpsOffs.push_back({RHS, OOK});
9484 // OpenMP [2.11.1.1, Restrictions, p.3]
9485 // A variable that is part of another variable (such as a field of a
9486 // structure) but is not an array element or an array section cannot
9487 // appear in a depend clause.
9488 auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr);
9489 auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr);
9490 auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr);
9491 if (!RefExpr->IgnoreParenImpCasts()->isLValue() ||
9492 (!ASE && !DE && !OASE) || (DE && !isa<VarDecl>(DE->getDecl())) ||
9496 .getNonReferenceType()
9497 ->isPointerType() &&
9498 !ASE->getBase()->getType().getNonReferenceType()->isArrayType())) {
9499 Diag(ELoc, diag::err_omp_expected_var_name_member_expr_or_array_item)
9500 << 0 << RefExpr->getSourceRange();
9504 Vars.push_back(RefExpr->IgnoreParenImpCasts());
9507 if (!CurContext->isDependentContext() && DepKind == OMPC_DEPEND_sink &&
9508 TotalDepCount > VarList.size() &&
9509 DSAStack->getParentOrderedRegionParam()) {
9510 Diag(EndLoc, diag::err_omp_depend_sink_expected_loop_iteration)
9511 << DSAStack->getParentLoopControlVariable(VarList.size() + 1);
9513 if (DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink &&
9517 auto *C = OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc,
9518 DepKind, DepLoc, ColonLoc, Vars);
9519 if (DepKind == OMPC_DEPEND_sink || DepKind == OMPC_DEPEND_source)
9520 DSAStack->addDoacrossDependClause(C, OpsOffs);
9524 OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
9525 SourceLocation LParenLoc,
9526 SourceLocation EndLoc) {
9527 Expr *ValExpr = Device;
9529 // OpenMP [2.9.1, Restrictions]
9530 // The device expression must evaluate to a non-negative integer value.
9531 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_device,
9532 /*StrictlyPositive=*/false))
9535 return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc);
9538 static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc,
9539 DSAStackTy *Stack, CXXRecordDecl *RD) {
9540 if (!RD || RD->isInvalidDecl())
9543 auto QTy = SemaRef.Context.getRecordType(RD);
9544 if (RD->isDynamicClass()) {
9545 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
9546 SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target);
9550 bool IsCorrect = true;
9551 for (auto *I : DC->decls()) {
9553 if (auto *MD = dyn_cast<CXXMethodDecl>(I)) {
9554 if (MD->isStatic()) {
9555 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
9556 SemaRef.Diag(MD->getLocation(),
9557 diag::note_omp_static_member_in_target);
9560 } else if (auto *VD = dyn_cast<VarDecl>(I)) {
9561 if (VD->isStaticDataMember()) {
9562 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
9563 SemaRef.Diag(VD->getLocation(),
9564 diag::note_omp_static_member_in_target);
9571 for (auto &I : RD->bases()) {
9572 if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack,
9573 I.getType()->getAsCXXRecordDecl()))
9579 static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
9580 DSAStackTy *Stack, QualType QTy) {
9582 if (QTy->isIncompleteType(&ND)) {
9583 SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
9585 } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) {
9586 if (!RD->isInvalidDecl() && !IsCXXRecordForMappable(SemaRef, SL, Stack, RD))
9592 /// \brief Return true if it can be proven that the provided array expression
9593 /// (array section or array subscript) does NOT specify the whole size of the
9594 /// array whose base type is \a BaseQTy.
9595 static bool CheckArrayExpressionDoesNotReferToWholeSize(Sema &SemaRef,
9598 auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
9600 // If this is an array subscript, it refers to the whole size if the size of
9601 // the dimension is constant and equals 1. Also, an array section assumes the
9602 // format of an array subscript if no colon is used.
9603 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid())) {
9604 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
9605 return ATy->getSize().getSExtValue() != 1;
9606 // Size can't be evaluated statically.
9610 assert(OASE && "Expecting array section if not an array subscript.");
9611 auto *LowerBound = OASE->getLowerBound();
9612 auto *Length = OASE->getLength();
9614 // If there is a lower bound that does not evaluates to zero, we are not
9615 // covering the whole dimension.
9617 llvm::APSInt ConstLowerBound;
9618 if (!LowerBound->EvaluateAsInt(ConstLowerBound, SemaRef.getASTContext()))
9619 return false; // Can't get the integer value as a constant.
9620 if (ConstLowerBound.getSExtValue())
9624 // If we don't have a length we covering the whole dimension.
9628 // If the base is a pointer, we don't have a way to get the size of the
9630 if (BaseQTy->isPointerType())
9633 // We can only check if the length is the same as the size of the dimension
9634 // if we have a constant array.
9635 auto *CATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr());
9639 llvm::APSInt ConstLength;
9640 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
9641 return false; // Can't get the integer value as a constant.
9643 return CATy->getSize().getSExtValue() != ConstLength.getSExtValue();
9646 // Return true if it can be proven that the provided array expression (array
9647 // section or array subscript) does NOT specify a single element of the array
9648 // whose base type is \a BaseQTy.
9649 static bool CheckArrayExpressionDoesNotReferToUnitySize(Sema &SemaRef,
9652 auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
9654 // An array subscript always refer to a single element. Also, an array section
9655 // assumes the format of an array subscript if no colon is used.
9656 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid()))
9659 assert(OASE && "Expecting array section if not an array subscript.");
9660 auto *Length = OASE->getLength();
9662 // If we don't have a length we have to check if the array has unitary size
9663 // for this dimension. Also, we should always expect a length if the base type
9666 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
9667 return ATy->getSize().getSExtValue() != 1;
9668 // We cannot assume anything.
9672 // Check if the length evaluates to 1.
9673 llvm::APSInt ConstLength;
9674 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
9675 return false; // Can't get the integer value as a constant.
9677 return ConstLength.getSExtValue() != 1;
9680 // Return the expression of the base of the mappable expression or null if it
9681 // cannot be determined and do all the necessary checks to see if the expression
9682 // is valid as a standalone mappable expression. In the process, record all the
9683 // components of the expression.
9684 static Expr *CheckMapClauseExpressionBase(
9685 Sema &SemaRef, Expr *E,
9686 OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents,
9687 OpenMPClauseKind CKind) {
9688 SourceLocation ELoc = E->getExprLoc();
9689 SourceRange ERange = E->getSourceRange();
9691 // The base of elements of list in a map clause have to be either:
9692 // - a reference to variable or field.
9693 // - a member expression.
9694 // - an array expression.
9696 // E.g. if we have the expression 'r.S.Arr[:12]', we want to retrieve the
9697 // reference to 'r'.
9704 // #pragma omp target map (S.Arr[:12]);
9708 // We want to retrieve the member expression 'this->S';
9710 Expr *RelevantExpr = nullptr;
9712 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.2]
9713 // If a list item is an array section, it must specify contiguous storage.
9715 // For this restriction it is sufficient that we make sure only references
9716 // to variables or fields and array expressions, and that no array sections
9717 // exist except in the rightmost expression (unless they cover the whole
9718 // dimension of the array). E.g. these would be invalid:
9720 // r.ArrS[3:5].Arr[6:7]
9724 // but these would be valid:
9725 // r.ArrS[3].Arr[6:7]
9729 bool AllowUnitySizeArraySection = true;
9730 bool AllowWholeSizeArraySection = true;
9732 while (!RelevantExpr) {
9733 E = E->IgnoreParenImpCasts();
9735 if (auto *CurE = dyn_cast<DeclRefExpr>(E)) {
9736 if (!isa<VarDecl>(CurE->getDecl()))
9739 RelevantExpr = CurE;
9741 // If we got a reference to a declaration, we should not expect any array
9742 // section before that.
9743 AllowUnitySizeArraySection = false;
9744 AllowWholeSizeArraySection = false;
9746 // Record the component.
9747 CurComponents.push_back(OMPClauseMappableExprCommon::MappableComponent(
9748 CurE, CurE->getDecl()));
9752 if (auto *CurE = dyn_cast<MemberExpr>(E)) {
9753 auto *BaseE = CurE->getBase()->IgnoreParenImpCasts();
9755 if (isa<CXXThisExpr>(BaseE))
9756 // We found a base expression: this->Val.
9757 RelevantExpr = CurE;
9761 if (!isa<FieldDecl>(CurE->getMemberDecl())) {
9762 SemaRef.Diag(ELoc, diag::err_omp_expected_access_to_data_field)
9763 << CurE->getSourceRange();
9767 auto *FD = cast<FieldDecl>(CurE->getMemberDecl());
9769 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3]
9770 // A bit-field cannot appear in a map clause.
9772 if (FD->isBitField()) {
9773 SemaRef.Diag(ELoc, diag::err_omp_bit_fields_forbidden_in_clause)
9774 << CurE->getSourceRange() << getOpenMPClauseName(CKind);
9778 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
9779 // If the type of a list item is a reference to a type T then the type
9780 // will be considered to be T for all purposes of this clause.
9781 QualType CurType = BaseE->getType().getNonReferenceType();
9783 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.2]
9784 // A list item cannot be a variable that is a member of a structure with
9787 if (auto *RT = CurType->getAs<RecordType>())
9788 if (RT->isUnionType()) {
9789 SemaRef.Diag(ELoc, diag::err_omp_union_type_not_allowed)
9790 << CurE->getSourceRange();
9794 // If we got a member expression, we should not expect any array section
9797 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7]
9798 // If a list item is an element of a structure, only the rightmost symbol
9799 // of the variable reference can be an array section.
9801 AllowUnitySizeArraySection = false;
9802 AllowWholeSizeArraySection = false;
9804 // Record the component.
9805 CurComponents.push_back(
9806 OMPClauseMappableExprCommon::MappableComponent(CurE, FD));
9810 if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) {
9811 E = CurE->getBase()->IgnoreParenImpCasts();
9813 if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) {
9814 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
9815 << 0 << CurE->getSourceRange();
9819 // If we got an array subscript that express the whole dimension we
9820 // can have any array expressions before. If it only expressing part of
9821 // the dimension, we can only have unitary-size array expressions.
9822 if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE,
9824 AllowWholeSizeArraySection = false;
9826 // Record the component - we don't have any declaration associated.
9827 CurComponents.push_back(
9828 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
9832 if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) {
9833 E = CurE->getBase()->IgnoreParenImpCasts();
9836 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
9838 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
9839 // If the type of a list item is a reference to a type T then the type
9840 // will be considered to be T for all purposes of this clause.
9841 if (CurType->isReferenceType())
9842 CurType = CurType->getPointeeType();
9844 bool IsPointer = CurType->isAnyPointerType();
9846 if (!IsPointer && !CurType->isArrayType()) {
9847 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
9848 << 0 << CurE->getSourceRange();
9853 CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, CurType);
9855 CheckArrayExpressionDoesNotReferToUnitySize(SemaRef, CurE, CurType);
9857 if (AllowWholeSizeArraySection) {
9858 // Any array section is currently allowed. Allowing a whole size array
9859 // section implies allowing a unity array section as well.
9861 // If this array section refers to the whole dimension we can still
9862 // accept other array sections before this one, except if the base is a
9863 // pointer. Otherwise, only unitary sections are accepted.
9864 if (NotWhole || IsPointer)
9865 AllowWholeSizeArraySection = false;
9866 } else if (AllowUnitySizeArraySection && NotUnity) {
9867 // A unity or whole array section is not allowed and that is not
9868 // compatible with the properties of the current array section.
9870 ELoc, diag::err_array_section_does_not_specify_contiguous_storage)
9871 << CurE->getSourceRange();
9875 // Record the component - we don't have any declaration associated.
9876 CurComponents.push_back(
9877 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
9881 // If nothing else worked, this is not a valid map clause expression.
9883 diag::err_omp_expected_named_var_member_or_array_expression)
9888 return RelevantExpr;
9891 // Return true if expression E associated with value VD has conflicts with other
9893 static bool CheckMapConflicts(
9894 Sema &SemaRef, DSAStackTy *DSAS, ValueDecl *VD, Expr *E,
9895 bool CurrentRegionOnly,
9896 OMPClauseMappableExprCommon::MappableExprComponentListRef CurComponents,
9897 OpenMPClauseKind CKind) {
9899 SourceLocation ELoc = E->getExprLoc();
9900 SourceRange ERange = E->getSourceRange();
9902 // In order to easily check the conflicts we need to match each component of
9903 // the expression under test with the components of the expressions that are
9904 // already in the stack.
9906 assert(!CurComponents.empty() && "Map clause expression with no components!");
9907 assert(CurComponents.back().getAssociatedDeclaration() == VD &&
9908 "Map clause expression with unexpected base!");
9910 // Variables to help detecting enclosing problems in data environment nests.
9911 bool IsEnclosedByDataEnvironmentExpr = false;
9912 const Expr *EnclosingExpr = nullptr;
9914 bool FoundError = DSAS->checkMappableExprComponentListsForDecl(
9915 VD, CurrentRegionOnly,
9916 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
9918 OpenMPClauseKind) -> bool {
9920 assert(!StackComponents.empty() &&
9921 "Map clause expression with no components!");
9922 assert(StackComponents.back().getAssociatedDeclaration() == VD &&
9923 "Map clause expression with unexpected base!");
9925 // The whole expression in the stack.
9926 auto *RE = StackComponents.front().getAssociatedExpression();
9928 // Expressions must start from the same base. Here we detect at which
9929 // point both expressions diverge from each other and see if we can
9930 // detect if the memory referred to both expressions is contiguous and
9932 auto CI = CurComponents.rbegin();
9933 auto CE = CurComponents.rend();
9934 auto SI = StackComponents.rbegin();
9935 auto SE = StackComponents.rend();
9936 for (; CI != CE && SI != SE; ++CI, ++SI) {
9938 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.3]
9939 // At most one list item can be an array item derived from a given
9940 // variable in map clauses of the same construct.
9941 if (CurrentRegionOnly &&
9942 (isa<ArraySubscriptExpr>(CI->getAssociatedExpression()) ||
9943 isa<OMPArraySectionExpr>(CI->getAssociatedExpression())) &&
9944 (isa<ArraySubscriptExpr>(SI->getAssociatedExpression()) ||
9945 isa<OMPArraySectionExpr>(SI->getAssociatedExpression()))) {
9946 SemaRef.Diag(CI->getAssociatedExpression()->getExprLoc(),
9947 diag::err_omp_multiple_array_items_in_map_clause)
9948 << CI->getAssociatedExpression()->getSourceRange();
9949 SemaRef.Diag(SI->getAssociatedExpression()->getExprLoc(),
9950 diag::note_used_here)
9951 << SI->getAssociatedExpression()->getSourceRange();
9955 // Do both expressions have the same kind?
9956 if (CI->getAssociatedExpression()->getStmtClass() !=
9957 SI->getAssociatedExpression()->getStmtClass())
9960 // Are we dealing with different variables/fields?
9961 if (CI->getAssociatedDeclaration() != SI->getAssociatedDeclaration())
9964 // Check if the extra components of the expressions in the enclosing
9965 // data environment are redundant for the current base declaration.
9966 // If they are, the maps completely overlap, which is legal.
9967 for (; SI != SE; ++SI) {
9970 dyn_cast<ArraySubscriptExpr>(SI->getAssociatedExpression())) {
9971 Type = ASE->getBase()->IgnoreParenImpCasts()->getType();
9972 } else if (auto *OASE = dyn_cast<OMPArraySectionExpr>(
9973 SI->getAssociatedExpression())) {
9974 auto *E = OASE->getBase()->IgnoreParenImpCasts();
9976 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
9978 if (Type.isNull() || Type->isAnyPointerType() ||
9979 CheckArrayExpressionDoesNotReferToWholeSize(
9980 SemaRef, SI->getAssociatedExpression(), Type))
9984 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
9985 // List items of map clauses in the same construct must not share
9986 // original storage.
9988 // If the expressions are exactly the same or one is a subset of the
9989 // other, it means they are sharing storage.
9990 if (CI == CE && SI == SE) {
9991 if (CurrentRegionOnly) {
9992 if (CKind == OMPC_map)
9993 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
9995 assert(CKind == OMPC_to || CKind == OMPC_from);
9996 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
9999 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10000 << RE->getSourceRange();
10003 // If we find the same expression in the enclosing data environment,
10005 IsEnclosedByDataEnvironmentExpr = true;
10010 QualType DerivedType =
10011 std::prev(CI)->getAssociatedDeclaration()->getType();
10012 SourceLocation DerivedLoc =
10013 std::prev(CI)->getAssociatedExpression()->getExprLoc();
10015 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10016 // If the type of a list item is a reference to a type T then the type
10017 // will be considered to be T for all purposes of this clause.
10018 DerivedType = DerivedType.getNonReferenceType();
10020 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.1]
10021 // A variable for which the type is pointer and an array section
10022 // derived from that variable must not appear as list items of map
10023 // clauses of the same construct.
10025 // Also, cover one of the cases in:
10026 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10027 // If any part of the original storage of a list item has corresponding
10028 // storage in the device data environment, all of the original storage
10029 // must have corresponding storage in the device data environment.
10031 if (DerivedType->isAnyPointerType()) {
10032 if (CI == CE || SI == SE) {
10035 diag::err_omp_pointer_mapped_along_with_derived_section)
10038 assert(CI != CE && SI != SE);
10039 SemaRef.Diag(DerivedLoc, diag::err_omp_same_pointer_derreferenced)
10042 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10043 << RE->getSourceRange();
10047 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10048 // List items of map clauses in the same construct must not share
10049 // original storage.
10051 // An expression is a subset of the other.
10052 if (CurrentRegionOnly && (CI == CE || SI == SE)) {
10053 if (CKind == OMPC_map)
10054 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10056 assert(CKind == OMPC_to || CKind == OMPC_from);
10057 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10060 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10061 << RE->getSourceRange();
10065 // The current expression uses the same base as other expression in the
10066 // data environment but does not contain it completely.
10067 if (!CurrentRegionOnly && SI != SE)
10068 EnclosingExpr = RE;
10070 // The current expression is a subset of the expression in the data
10072 IsEnclosedByDataEnvironmentExpr |=
10073 (!CurrentRegionOnly && CI != CE && SI == SE);
10078 if (CurrentRegionOnly)
10081 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10082 // If any part of the original storage of a list item has corresponding
10083 // storage in the device data environment, all of the original storage must
10084 // have corresponding storage in the device data environment.
10085 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.6]
10086 // If a list item is an element of a structure, and a different element of
10087 // the structure has a corresponding list item in the device data environment
10088 // prior to a task encountering the construct associated with the map clause,
10089 // then the list item must also have a corresponding list item in the device
10090 // data environment prior to the task encountering the construct.
10092 if (EnclosingExpr && !IsEnclosedByDataEnvironmentExpr) {
10094 diag::err_omp_original_storage_is_shared_and_does_not_contain)
10096 SemaRef.Diag(EnclosingExpr->getExprLoc(), diag::note_used_here)
10097 << EnclosingExpr->getSourceRange();
10105 // Utility struct that gathers all the related lists associated with a mappable
10107 struct MappableVarListInfo final {
10108 // The list of expressions.
10109 ArrayRef<Expr *> VarList;
10110 // The list of processed expressions.
10111 SmallVector<Expr *, 16> ProcessedVarList;
10112 // The mappble components for each expression.
10113 OMPClauseMappableExprCommon::MappableExprComponentLists VarComponents;
10114 // The base declaration of the variable.
10115 SmallVector<ValueDecl *, 16> VarBaseDeclarations;
10117 MappableVarListInfo(ArrayRef<Expr *> VarList) : VarList(VarList) {
10118 // We have a list of components and base declarations for each entry in the
10120 VarComponents.reserve(VarList.size());
10121 VarBaseDeclarations.reserve(VarList.size());
10126 // Check the validity of the provided variable list for the provided clause kind
10127 // \a CKind. In the check process the valid expressions, and mappable expression
10128 // components and variables are extracted and used to fill \a Vars,
10129 // \a ClauseComponents, and \a ClauseBaseDeclarations. \a MapType and
10130 // \a IsMapTypeImplicit are expected to be valid if the clause kind is 'map'.
10132 checkMappableExpressionList(Sema &SemaRef, DSAStackTy *DSAS,
10133 OpenMPClauseKind CKind, MappableVarListInfo &MVLI,
10134 SourceLocation StartLoc,
10135 OpenMPMapClauseKind MapType = OMPC_MAP_unknown,
10136 bool IsMapTypeImplicit = false) {
10137 // We only expect mappable expressions in 'to', 'from', and 'map' clauses.
10138 assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from) &&
10139 "Unexpected clause kind with mappable expressions!");
10141 // Keep track of the mappable components and base declarations in this clause.
10142 // Each entry in the list is going to have a list of components associated. We
10143 // record each set of the components so that we can build the clause later on.
10144 // In the end we should have the same amount of declarations and component
10147 for (auto &RE : MVLI.VarList) {
10148 assert(RE && "Null expr in omp to/from/map clause");
10149 SourceLocation ELoc = RE->getExprLoc();
10151 auto *VE = RE->IgnoreParenLValueCasts();
10153 if (VE->isValueDependent() || VE->isTypeDependent() ||
10154 VE->isInstantiationDependent() ||
10155 VE->containsUnexpandedParameterPack()) {
10156 // We can only analyze this information once the missing information is
10158 MVLI.ProcessedVarList.push_back(RE);
10162 auto *SimpleExpr = RE->IgnoreParenCasts();
10164 if (!RE->IgnoreParenImpCasts()->isLValue()) {
10166 diag::err_omp_expected_named_var_member_or_array_expression)
10167 << RE->getSourceRange();
10171 OMPClauseMappableExprCommon::MappableExprComponentList CurComponents;
10172 ValueDecl *CurDeclaration = nullptr;
10174 // Obtain the array or member expression bases if required. Also, fill the
10175 // components array with all the components identified in the process.
10177 CheckMapClauseExpressionBase(SemaRef, SimpleExpr, CurComponents, CKind);
10181 assert(!CurComponents.empty() &&
10182 "Invalid mappable expression information.");
10184 // For the following checks, we rely on the base declaration which is
10185 // expected to be associated with the last component. The declaration is
10186 // expected to be a variable or a field (if 'this' is being mapped).
10187 CurDeclaration = CurComponents.back().getAssociatedDeclaration();
10188 assert(CurDeclaration && "Null decl on map clause.");
10190 CurDeclaration->isCanonicalDecl() &&
10191 "Expecting components to have associated only canonical declarations.");
10193 auto *VD = dyn_cast<VarDecl>(CurDeclaration);
10194 auto *FD = dyn_cast<FieldDecl>(CurDeclaration);
10196 assert((VD || FD) && "Only variables or fields are expected here!");
10199 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.10]
10200 // threadprivate variables cannot appear in a map clause.
10201 // OpenMP 4.5 [2.10.5, target update Construct]
10202 // threadprivate variables cannot appear in a from clause.
10203 if (VD && DSAS->isThreadPrivate(VD)) {
10204 auto DVar = DSAS->getTopDSA(VD, false);
10205 SemaRef.Diag(ELoc, diag::err_omp_threadprivate_in_clause)
10206 << getOpenMPClauseName(CKind);
10207 ReportOriginalDSA(SemaRef, DSAS, VD, DVar);
10211 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10212 // A list item cannot appear in both a map clause and a data-sharing
10213 // attribute clause on the same construct.
10215 // Check conflicts with other map clause expressions. We check the conflicts
10216 // with the current construct separately from the enclosing data
10217 // environment, because the restrictions are different. We only have to
10218 // check conflicts across regions for the map clauses.
10219 if (CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10220 /*CurrentRegionOnly=*/true, CurComponents, CKind))
10222 if (CKind == OMPC_map &&
10223 CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10224 /*CurrentRegionOnly=*/false, CurComponents, CKind))
10227 // OpenMP 4.5 [2.10.5, target update Construct]
10228 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10229 // If the type of a list item is a reference to a type T then the type will
10230 // be considered to be T for all purposes of this clause.
10231 QualType Type = CurDeclaration->getType().getNonReferenceType();
10233 // OpenMP 4.5 [2.10.5, target update Construct, Restrictions, p.4]
10234 // A list item in a to or from clause must have a mappable type.
10235 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10236 // A list item must have a mappable type.
10237 if (!CheckTypeMappable(VE->getExprLoc(), VE->getSourceRange(), SemaRef,
10241 if (CKind == OMPC_map) {
10242 // target enter data
10243 // OpenMP [2.10.2, Restrictions, p. 99]
10244 // A map-type must be specified in all map clauses and must be either
10246 OpenMPDirectiveKind DKind = DSAS->getCurrentDirective();
10247 if (DKind == OMPD_target_enter_data &&
10248 !(MapType == OMPC_MAP_to || MapType == OMPC_MAP_alloc)) {
10249 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10250 << (IsMapTypeImplicit ? 1 : 0)
10251 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10252 << getOpenMPDirectiveName(DKind);
10256 // target exit_data
10257 // OpenMP [2.10.3, Restrictions, p. 102]
10258 // A map-type must be specified in all map clauses and must be either
10259 // from, release, or delete.
10260 if (DKind == OMPD_target_exit_data &&
10261 !(MapType == OMPC_MAP_from || MapType == OMPC_MAP_release ||
10262 MapType == OMPC_MAP_delete)) {
10263 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10264 << (IsMapTypeImplicit ? 1 : 0)
10265 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10266 << getOpenMPDirectiveName(DKind);
10270 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
10271 // A list item cannot appear in both a map clause and a data-sharing
10272 // attribute clause on the same construct
10273 if ((DKind == OMPD_target || DKind == OMPD_target_teams ||
10274 DKind == OMPD_target_teams_distribute ||
10275 DKind == OMPD_target_teams_distribute_parallel_for ||
10276 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
10277 DKind == OMPD_target_teams_distribute_simd) && VD) {
10278 auto DVar = DSAS->getTopDSA(VD, false);
10279 if (isOpenMPPrivate(DVar.CKind)) {
10280 SemaRef.Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
10281 << getOpenMPClauseName(DVar.CKind)
10282 << getOpenMPClauseName(OMPC_map)
10283 << getOpenMPDirectiveName(DSAS->getCurrentDirective());
10284 ReportOriginalDSA(SemaRef, DSAS, CurDeclaration, DVar);
10290 // Save the current expression.
10291 MVLI.ProcessedVarList.push_back(RE);
10293 // Store the components in the stack so that they can be used to check
10294 // against other clauses later on.
10295 DSAS->addMappableExpressionComponents(CurDeclaration, CurComponents,
10296 /*WhereFoundClauseKind=*/OMPC_map);
10298 // Save the components and declaration to create the clause. For purposes of
10299 // the clause creation, any component list that has has base 'this' uses
10300 // null as base declaration.
10301 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
10302 MVLI.VarComponents.back().append(CurComponents.begin(),
10303 CurComponents.end());
10304 MVLI.VarBaseDeclarations.push_back(isa<MemberExpr>(BE) ? nullptr
10310 Sema::ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,
10311 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
10312 SourceLocation MapLoc, SourceLocation ColonLoc,
10313 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
10314 SourceLocation LParenLoc, SourceLocation EndLoc) {
10315 MappableVarListInfo MVLI(VarList);
10316 checkMappableExpressionList(*this, DSAStack, OMPC_map, MVLI, StartLoc,
10317 MapType, IsMapTypeImplicit);
10319 // We need to produce a map clause even if we don't have variables so that
10320 // other diagnostics related with non-existing map clauses are accurate.
10321 return OMPMapClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10322 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
10323 MVLI.VarComponents, MapTypeModifier, MapType,
10324 IsMapTypeImplicit, MapLoc);
10327 QualType Sema::ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
10328 TypeResult ParsedType) {
10329 assert(ParsedType.isUsable());
10331 QualType ReductionType = GetTypeFromParser(ParsedType.get());
10332 if (ReductionType.isNull())
10335 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions, C\C++
10336 // A type name in a declare reduction directive cannot be a function type, an
10337 // array type, a reference type, or a type qualified with const, volatile or
10339 if (ReductionType.hasQualifiers()) {
10340 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 0;
10344 if (ReductionType->isFunctionType()) {
10345 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 1;
10348 if (ReductionType->isReferenceType()) {
10349 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 2;
10352 if (ReductionType->isArrayType()) {
10353 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 3;
10356 return ReductionType;
10359 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveStart(
10360 Scope *S, DeclContext *DC, DeclarationName Name,
10361 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
10362 AccessSpecifier AS, Decl *PrevDeclInScope) {
10363 SmallVector<Decl *, 8> Decls;
10364 Decls.reserve(ReductionTypes.size());
10366 LookupResult Lookup(*this, Name, SourceLocation(), LookupOMPReductionName,
10368 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
10369 // A reduction-identifier may not be re-declared in the current scope for the
10370 // same type or for a type that is compatible according to the base language
10372 llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
10373 OMPDeclareReductionDecl *PrevDRD = nullptr;
10374 bool InCompoundScope = true;
10375 if (S != nullptr) {
10376 // Find previous declaration with the same name not referenced in other
10378 FunctionScopeInfo *ParentFn = getEnclosingFunction();
10380 (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty();
10381 LookupName(Lookup, S);
10382 FilterLookupForScope(Lookup, DC, S, /*ConsiderLinkage=*/false,
10383 /*AllowInlineNamespace=*/false);
10384 llvm::DenseMap<OMPDeclareReductionDecl *, bool> UsedAsPrevious;
10385 auto Filter = Lookup.makeFilter();
10386 while (Filter.hasNext()) {
10387 auto *PrevDecl = cast<OMPDeclareReductionDecl>(Filter.next());
10388 if (InCompoundScope) {
10389 auto I = UsedAsPrevious.find(PrevDecl);
10390 if (I == UsedAsPrevious.end())
10391 UsedAsPrevious[PrevDecl] = false;
10392 if (auto *D = PrevDecl->getPrevDeclInScope())
10393 UsedAsPrevious[D] = true;
10395 PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] =
10396 PrevDecl->getLocation();
10399 if (InCompoundScope) {
10400 for (auto &PrevData : UsedAsPrevious) {
10401 if (!PrevData.second) {
10402 PrevDRD = PrevData.first;
10407 } else if (PrevDeclInScope != nullptr) {
10408 auto *PrevDRDInScope = PrevDRD =
10409 cast<OMPDeclareReductionDecl>(PrevDeclInScope);
10411 PreviousRedeclTypes[PrevDRDInScope->getType().getCanonicalType()] =
10412 PrevDRDInScope->getLocation();
10413 PrevDRDInScope = PrevDRDInScope->getPrevDeclInScope();
10414 } while (PrevDRDInScope != nullptr);
10416 for (auto &TyData : ReductionTypes) {
10417 auto I = PreviousRedeclTypes.find(TyData.first.getCanonicalType());
10418 bool Invalid = false;
10419 if (I != PreviousRedeclTypes.end()) {
10420 Diag(TyData.second, diag::err_omp_declare_reduction_redefinition)
10422 Diag(I->second, diag::note_previous_definition);
10425 PreviousRedeclTypes[TyData.first.getCanonicalType()] = TyData.second;
10426 auto *DRD = OMPDeclareReductionDecl::Create(Context, DC, TyData.second,
10427 Name, TyData.first, PrevDRD);
10429 DRD->setAccess(AS);
10430 Decls.push_back(DRD);
10432 DRD->setInvalidDecl();
10437 return DeclGroupPtrTy::make(
10438 DeclGroupRef::Create(Context, Decls.begin(), Decls.size()));
10441 void Sema::ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D) {
10442 auto *DRD = cast<OMPDeclareReductionDecl>(D);
10444 // Enter new function scope.
10445 PushFunctionScope();
10446 getCurFunction()->setHasBranchProtectedScope();
10447 getCurFunction()->setHasOMPDeclareReductionCombiner();
10450 PushDeclContext(S, DRD);
10454 PushExpressionEvaluationContext(PotentiallyEvaluated);
10456 QualType ReductionType = DRD->getType();
10457 // Create 'T* omp_parm;T omp_in;'. All references to 'omp_in' will
10458 // be replaced by '*omp_parm' during codegen. This required because 'omp_in'
10459 // uses semantics of argument handles by value, but it should be passed by
10460 // reference. C lang does not support references, so pass all parameters as
10462 // Create 'T omp_in;' variable.
10464 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_in");
10465 // Create 'T* omp_parm;T omp_out;'. All references to 'omp_out' will
10466 // be replaced by '*omp_parm' during codegen. This required because 'omp_out'
10467 // uses semantics of argument handles by value, but it should be passed by
10468 // reference. C lang does not support references, so pass all parameters as
10470 // Create 'T omp_out;' variable.
10472 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_out");
10473 if (S != nullptr) {
10474 PushOnScopeChains(OmpInParm, S);
10475 PushOnScopeChains(OmpOutParm, S);
10477 DRD->addDecl(OmpInParm);
10478 DRD->addDecl(OmpOutParm);
10482 void Sema::ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner) {
10483 auto *DRD = cast<OMPDeclareReductionDecl>(D);
10484 DiscardCleanupsInEvaluationContext();
10485 PopExpressionEvaluationContext();
10488 PopFunctionScopeInfo();
10490 if (Combiner != nullptr)
10491 DRD->setCombiner(Combiner);
10493 DRD->setInvalidDecl();
10496 void Sema::ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D) {
10497 auto *DRD = cast<OMPDeclareReductionDecl>(D);
10499 // Enter new function scope.
10500 PushFunctionScope();
10501 getCurFunction()->setHasBranchProtectedScope();
10504 PushDeclContext(S, DRD);
10508 PushExpressionEvaluationContext(PotentiallyEvaluated);
10510 QualType ReductionType = DRD->getType();
10511 // Create 'T* omp_parm;T omp_priv;'. All references to 'omp_priv' will
10512 // be replaced by '*omp_parm' during codegen. This required because 'omp_priv'
10513 // uses semantics of argument handles by value, but it should be passed by
10514 // reference. C lang does not support references, so pass all parameters as
10516 // Create 'T omp_priv;' variable.
10517 auto *OmpPrivParm =
10518 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_priv");
10519 // Create 'T* omp_parm;T omp_orig;'. All references to 'omp_orig' will
10520 // be replaced by '*omp_parm' during codegen. This required because 'omp_orig'
10521 // uses semantics of argument handles by value, but it should be passed by
10522 // reference. C lang does not support references, so pass all parameters as
10524 // Create 'T omp_orig;' variable.
10525 auto *OmpOrigParm =
10526 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_orig");
10527 if (S != nullptr) {
10528 PushOnScopeChains(OmpPrivParm, S);
10529 PushOnScopeChains(OmpOrigParm, S);
10531 DRD->addDecl(OmpPrivParm);
10532 DRD->addDecl(OmpOrigParm);
10536 void Sema::ActOnOpenMPDeclareReductionInitializerEnd(Decl *D,
10537 Expr *Initializer) {
10538 auto *DRD = cast<OMPDeclareReductionDecl>(D);
10539 DiscardCleanupsInEvaluationContext();
10540 PopExpressionEvaluationContext();
10543 PopFunctionScopeInfo();
10545 if (Initializer != nullptr)
10546 DRD->setInitializer(Initializer);
10548 DRD->setInvalidDecl();
10551 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveEnd(
10552 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid) {
10553 for (auto *D : DeclReductions.get()) {
10555 auto *DRD = cast<OMPDeclareReductionDecl>(D);
10557 PushOnScopeChains(DRD, S, /*AddToContext=*/false);
10559 D->setInvalidDecl();
10561 return DeclReductions;
10564 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams,
10565 SourceLocation StartLoc,
10566 SourceLocation LParenLoc,
10567 SourceLocation EndLoc) {
10568 Expr *ValExpr = NumTeams;
10570 // OpenMP [teams Constrcut, Restrictions]
10571 // The num_teams expression must evaluate to a positive integer value.
10572 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_teams,
10573 /*StrictlyPositive=*/true))
10576 return new (Context) OMPNumTeamsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10579 OMPClause *Sema::ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
10580 SourceLocation StartLoc,
10581 SourceLocation LParenLoc,
10582 SourceLocation EndLoc) {
10583 Expr *ValExpr = ThreadLimit;
10585 // OpenMP [teams Constrcut, Restrictions]
10586 // The thread_limit expression must evaluate to a positive integer value.
10587 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_thread_limit,
10588 /*StrictlyPositive=*/true))
10591 return new (Context)
10592 OMPThreadLimitClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10595 OMPClause *Sema::ActOnOpenMPPriorityClause(Expr *Priority,
10596 SourceLocation StartLoc,
10597 SourceLocation LParenLoc,
10598 SourceLocation EndLoc) {
10599 Expr *ValExpr = Priority;
10601 // OpenMP [2.9.1, task Constrcut]
10602 // The priority-value is a non-negative numerical scalar expression.
10603 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_priority,
10604 /*StrictlyPositive=*/false))
10607 return new (Context) OMPPriorityClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10610 OMPClause *Sema::ActOnOpenMPGrainsizeClause(Expr *Grainsize,
10611 SourceLocation StartLoc,
10612 SourceLocation LParenLoc,
10613 SourceLocation EndLoc) {
10614 Expr *ValExpr = Grainsize;
10616 // OpenMP [2.9.2, taskloop Constrcut]
10617 // The parameter of the grainsize clause must be a positive integer
10619 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_grainsize,
10620 /*StrictlyPositive=*/true))
10623 return new (Context) OMPGrainsizeClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10626 OMPClause *Sema::ActOnOpenMPNumTasksClause(Expr *NumTasks,
10627 SourceLocation StartLoc,
10628 SourceLocation LParenLoc,
10629 SourceLocation EndLoc) {
10630 Expr *ValExpr = NumTasks;
10632 // OpenMP [2.9.2, taskloop Constrcut]
10633 // The parameter of the num_tasks clause must be a positive integer
10635 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_tasks,
10636 /*StrictlyPositive=*/true))
10639 return new (Context) OMPNumTasksClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10642 OMPClause *Sema::ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
10643 SourceLocation LParenLoc,
10644 SourceLocation EndLoc) {
10645 // OpenMP [2.13.2, critical construct, Description]
10646 // ... where hint-expression is an integer constant expression that evaluates
10647 // to a valid lock hint.
10648 ExprResult HintExpr = VerifyPositiveIntegerConstantInClause(Hint, OMPC_hint);
10649 if (HintExpr.isInvalid())
10651 return new (Context)
10652 OMPHintClause(HintExpr.get(), StartLoc, LParenLoc, EndLoc);
10655 OMPClause *Sema::ActOnOpenMPDistScheduleClause(
10656 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
10657 SourceLocation LParenLoc, SourceLocation KindLoc, SourceLocation CommaLoc,
10658 SourceLocation EndLoc) {
10659 if (Kind == OMPC_DIST_SCHEDULE_unknown) {
10660 std::string Values;
10662 Values += getOpenMPSimpleClauseTypeName(OMPC_dist_schedule, 0);
10664 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
10665 << Values << getOpenMPClauseName(OMPC_dist_schedule);
10668 Expr *ValExpr = ChunkSize;
10669 Stmt *HelperValStmt = nullptr;
10671 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
10672 !ChunkSize->isInstantiationDependent() &&
10673 !ChunkSize->containsUnexpandedParameterPack()) {
10674 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
10676 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
10677 if (Val.isInvalid())
10680 ValExpr = Val.get();
10682 // OpenMP [2.7.1, Restrictions]
10683 // chunk_size must be a loop invariant integer expression with a positive
10685 llvm::APSInt Result;
10686 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
10687 if (Result.isSigned() && !Result.isStrictlyPositive()) {
10688 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
10689 << "dist_schedule" << ChunkSize->getSourceRange();
10692 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
10693 !CurContext->isDependentContext()) {
10694 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
10695 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
10696 HelperValStmt = buildPreInits(Context, Captures);
10701 return new (Context)
10702 OMPDistScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc,
10703 Kind, ValExpr, HelperValStmt);
10706 OMPClause *Sema::ActOnOpenMPDefaultmapClause(
10707 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
10708 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
10709 SourceLocation KindLoc, SourceLocation EndLoc) {
10710 // OpenMP 4.5 only supports 'defaultmap(tofrom: scalar)'
10711 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom || Kind != OMPC_DEFAULTMAP_scalar) {
10713 SourceLocation Loc;
10715 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom) {
10716 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
10717 OMPC_DEFAULTMAP_MODIFIER_tofrom);
10720 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
10721 OMPC_DEFAULTMAP_scalar);
10725 Diag(Loc, diag::err_omp_unexpected_clause_value)
10726 << Value << getOpenMPClauseName(OMPC_defaultmap);
10730 return new (Context)
10731 OMPDefaultmapClause(StartLoc, LParenLoc, MLoc, KindLoc, EndLoc, Kind, M);
10734 bool Sema::ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc) {
10735 DeclContext *CurLexicalContext = getCurLexicalContext();
10736 if (!CurLexicalContext->isFileContext() &&
10737 !CurLexicalContext->isExternCContext() &&
10738 !CurLexicalContext->isExternCXXContext()) {
10739 Diag(Loc, diag::err_omp_region_not_file_context);
10742 if (IsInOpenMPDeclareTargetContext) {
10743 Diag(Loc, diag::err_omp_enclosed_declare_target);
10747 IsInOpenMPDeclareTargetContext = true;
10751 void Sema::ActOnFinishOpenMPDeclareTargetDirective() {
10752 assert(IsInOpenMPDeclareTargetContext &&
10753 "Unexpected ActOnFinishOpenMPDeclareTargetDirective");
10755 IsInOpenMPDeclareTargetContext = false;
10758 void Sema::ActOnOpenMPDeclareTargetName(Scope *CurScope,
10759 CXXScopeSpec &ScopeSpec,
10760 const DeclarationNameInfo &Id,
10761 OMPDeclareTargetDeclAttr::MapTypeTy MT,
10762 NamedDeclSetType &SameDirectiveDecls) {
10763 LookupResult Lookup(*this, Id, LookupOrdinaryName);
10764 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
10766 if (Lookup.isAmbiguous())
10768 Lookup.suppressDiagnostics();
10770 if (!Lookup.isSingleResult()) {
10771 if (TypoCorrection Corrected =
10772 CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr,
10773 llvm::make_unique<VarOrFuncDeclFilterCCC>(*this),
10774 CTK_ErrorRecovery)) {
10775 diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
10777 checkDeclIsAllowedInOpenMPTarget(nullptr, Corrected.getCorrectionDecl());
10781 Diag(Id.getLoc(), diag::err_undeclared_var_use) << Id.getName();
10785 NamedDecl *ND = Lookup.getAsSingle<NamedDecl>();
10786 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
10787 if (!SameDirectiveDecls.insert(cast<NamedDecl>(ND->getCanonicalDecl())))
10788 Diag(Id.getLoc(), diag::err_omp_declare_target_multiple) << Id.getName();
10790 if (!ND->hasAttr<OMPDeclareTargetDeclAttr>()) {
10791 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(Context, MT);
10793 if (ASTMutationListener *ML = Context.getASTMutationListener())
10794 ML->DeclarationMarkedOpenMPDeclareTarget(ND, A);
10795 checkDeclIsAllowedInOpenMPTarget(nullptr, ND);
10796 } else if (ND->getAttr<OMPDeclareTargetDeclAttr>()->getMapType() != MT) {
10797 Diag(Id.getLoc(), diag::err_omp_declare_target_to_and_link)
10801 Diag(Id.getLoc(), diag::err_omp_invalid_target_decl) << Id.getName();
10804 static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR,
10805 Sema &SemaRef, Decl *D) {
10808 Decl *LD = nullptr;
10809 if (isa<TagDecl>(D)) {
10810 LD = cast<TagDecl>(D)->getDefinition();
10811 } else if (isa<VarDecl>(D)) {
10812 LD = cast<VarDecl>(D)->getDefinition();
10814 // If this is an implicit variable that is legal and we do not need to do
10816 if (cast<VarDecl>(D)->isImplicit()) {
10817 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
10818 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
10820 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
10821 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
10825 } else if (isa<FunctionDecl>(D)) {
10826 const FunctionDecl *FD = nullptr;
10827 if (cast<FunctionDecl>(D)->hasBody(FD))
10828 LD = const_cast<FunctionDecl *>(FD);
10830 // If the definition is associated with the current declaration in the
10831 // target region (it can be e.g. a lambda) that is legal and we do not need
10832 // to do anything else.
10834 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
10835 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
10837 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
10838 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
10844 if (LD && !LD->hasAttr<OMPDeclareTargetDeclAttr>() &&
10845 (isa<VarDecl>(LD) || isa<FunctionDecl>(LD))) {
10846 // Outlined declaration is not declared target.
10847 if (LD->isOutOfLine()) {
10848 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
10849 SemaRef.Diag(SL, diag::note_used_here) << SR;
10851 DeclContext *DC = LD->getDeclContext();
10853 if (isa<FunctionDecl>(DC) &&
10854 cast<FunctionDecl>(DC)->hasAttr<OMPDeclareTargetDeclAttr>())
10856 DC = DC->getParent();
10861 // Is not declared in target context.
10862 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
10863 SemaRef.Diag(SL, diag::note_used_here) << SR;
10865 // Mark decl as declared target to prevent further diagnostic.
10866 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
10867 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
10869 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
10870 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
10874 static bool checkValueDeclInTarget(SourceLocation SL, SourceRange SR,
10875 Sema &SemaRef, DSAStackTy *Stack,
10877 if (VD->hasAttr<OMPDeclareTargetDeclAttr>())
10879 if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType()))
10884 void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) {
10885 if (!D || D->isInvalidDecl())
10887 SourceRange SR = E ? E->getSourceRange() : D->getSourceRange();
10888 SourceLocation SL = E ? E->getLocStart() : D->getLocation();
10889 // 2.10.6: threadprivate variable cannot appear in a declare target directive.
10890 if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
10891 if (DSAStack->isThreadPrivate(VD)) {
10892 Diag(SL, diag::err_omp_threadprivate_in_target);
10893 ReportOriginalDSA(*this, DSAStack, VD, DSAStack->getTopDSA(VD, false));
10897 if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
10898 // Problem if any with var declared with incomplete type will be reported
10899 // as normal, so no need to check it here.
10900 if ((E || !VD->getType()->isIncompleteType()) &&
10901 !checkValueDeclInTarget(SL, SR, *this, DSAStack, VD)) {
10902 // Mark decl as declared target to prevent further diagnostic.
10903 if (isa<VarDecl>(VD) || isa<FunctionDecl>(VD)) {
10904 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
10905 Context, OMPDeclareTargetDeclAttr::MT_To);
10907 if (ASTMutationListener *ML = Context.getASTMutationListener())
10908 ML->DeclarationMarkedOpenMPDeclareTarget(VD, A);
10914 // Checking declaration inside declare target region.
10915 if (!D->hasAttr<OMPDeclareTargetDeclAttr>() &&
10916 (isa<VarDecl>(D) || isa<FunctionDecl>(D))) {
10917 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
10918 Context, OMPDeclareTargetDeclAttr::MT_To);
10920 if (ASTMutationListener *ML = Context.getASTMutationListener())
10921 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
10925 checkDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this, D);
10928 OMPClause *Sema::ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
10929 SourceLocation StartLoc,
10930 SourceLocation LParenLoc,
10931 SourceLocation EndLoc) {
10932 MappableVarListInfo MVLI(VarList);
10933 checkMappableExpressionList(*this, DSAStack, OMPC_to, MVLI, StartLoc);
10934 if (MVLI.ProcessedVarList.empty())
10937 return OMPToClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10938 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
10939 MVLI.VarComponents);
10942 OMPClause *Sema::ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
10943 SourceLocation StartLoc,
10944 SourceLocation LParenLoc,
10945 SourceLocation EndLoc) {
10946 MappableVarListInfo MVLI(VarList);
10947 checkMappableExpressionList(*this, DSAStack, OMPC_from, MVLI, StartLoc);
10948 if (MVLI.ProcessedVarList.empty())
10951 return OMPFromClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10952 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
10953 MVLI.VarComponents);
10956 OMPClause *Sema::ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
10957 SourceLocation StartLoc,
10958 SourceLocation LParenLoc,
10959 SourceLocation EndLoc) {
10960 MappableVarListInfo MVLI(VarList);
10961 SmallVector<Expr *, 8> PrivateCopies;
10962 SmallVector<Expr *, 8> Inits;
10964 for (auto &RefExpr : VarList) {
10965 assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause.");
10966 SourceLocation ELoc;
10967 SourceRange ERange;
10968 Expr *SimpleRefExpr = RefExpr;
10969 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
10971 // It will be analyzed later.
10972 MVLI.ProcessedVarList.push_back(RefExpr);
10973 PrivateCopies.push_back(nullptr);
10974 Inits.push_back(nullptr);
10976 ValueDecl *D = Res.first;
10980 QualType Type = D->getType();
10981 Type = Type.getNonReferenceType().getUnqualifiedType();
10983 auto *VD = dyn_cast<VarDecl>(D);
10985 // Item should be a pointer or reference to pointer.
10986 if (!Type->isPointerType()) {
10987 Diag(ELoc, diag::err_omp_usedeviceptr_not_a_pointer)
10988 << 0 << RefExpr->getSourceRange();
10992 // Build the private variable and the expression that refers to it.
10993 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
10994 D->hasAttrs() ? &D->getAttrs() : nullptr);
10995 if (VDPrivate->isInvalidDecl())
10998 CurContext->addDecl(VDPrivate);
10999 auto VDPrivateRefExpr = buildDeclRefExpr(
11000 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
11002 // Add temporary variable to initialize the private copy of the pointer.
11004 buildVarDecl(*this, RefExpr->getExprLoc(), Type, ".devptr.temp");
11005 auto *VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(),
11006 RefExpr->getExprLoc());
11007 AddInitializerToDecl(VDPrivate,
11008 DefaultLvalueConversion(VDInitRefExpr).get(),
11009 /*DirectInit=*/false);
11011 // If required, build a capture to implement the privatization initialized
11012 // with the current list item value.
11013 DeclRefExpr *Ref = nullptr;
11015 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
11016 MVLI.ProcessedVarList.push_back(VD ? RefExpr->IgnoreParens() : Ref);
11017 PrivateCopies.push_back(VDPrivateRefExpr);
11018 Inits.push_back(VDInitRefExpr);
11020 // We need to add a data sharing attribute for this variable to make sure it
11021 // is correctly captured. A variable that shows up in a use_device_ptr has
11022 // similar properties of a first private variable.
11023 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref);
11025 // Create a mappable component for the list item. List items in this clause
11026 // only need a component.
11027 MVLI.VarBaseDeclarations.push_back(D);
11028 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
11029 MVLI.VarComponents.back().push_back(
11030 OMPClauseMappableExprCommon::MappableComponent(SimpleRefExpr, D));
11033 if (MVLI.ProcessedVarList.empty())
11036 return OMPUseDevicePtrClause::Create(
11037 Context, StartLoc, LParenLoc, EndLoc, MVLI.ProcessedVarList,
11038 PrivateCopies, Inits, MVLI.VarBaseDeclarations, MVLI.VarComponents);
11041 OMPClause *Sema::ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11042 SourceLocation StartLoc,
11043 SourceLocation LParenLoc,
11044 SourceLocation EndLoc) {
11045 MappableVarListInfo MVLI(VarList);
11046 for (auto &RefExpr : VarList) {
11047 assert(RefExpr && "NULL expr in OpenMP is_device_ptr clause.");
11048 SourceLocation ELoc;
11049 SourceRange ERange;
11050 Expr *SimpleRefExpr = RefExpr;
11051 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11053 // It will be analyzed later.
11054 MVLI.ProcessedVarList.push_back(RefExpr);
11056 ValueDecl *D = Res.first;
11060 QualType Type = D->getType();
11061 // item should be a pointer or array or reference to pointer or array
11062 if (!Type.getNonReferenceType()->isPointerType() &&
11063 !Type.getNonReferenceType()->isArrayType()) {
11064 Diag(ELoc, diag::err_omp_argument_type_isdeviceptr)
11065 << 0 << RefExpr->getSourceRange();
11069 // Check if the declaration in the clause does not show up in any data
11070 // sharing attribute.
11071 auto DVar = DSAStack->getTopDSA(D, false);
11072 if (isOpenMPPrivate(DVar.CKind)) {
11073 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
11074 << getOpenMPClauseName(DVar.CKind)
11075 << getOpenMPClauseName(OMPC_is_device_ptr)
11076 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
11077 ReportOriginalDSA(*this, DSAStack, D, DVar);
11081 Expr *ConflictExpr;
11082 if (DSAStack->checkMappableExprComponentListsForDecl(
11083 D, /*CurrentRegionOnly=*/true,
11085 OMPClauseMappableExprCommon::MappableExprComponentListRef R,
11086 OpenMPClauseKind) -> bool {
11087 ConflictExpr = R.front().getAssociatedExpression();
11090 Diag(ELoc, diag::err_omp_map_shared_storage) << RefExpr->getSourceRange();
11091 Diag(ConflictExpr->getExprLoc(), diag::note_used_here)
11092 << ConflictExpr->getSourceRange();
11096 // Store the components in the stack so that they can be used to check
11097 // against other clauses later on.
11098 OMPClauseMappableExprCommon::MappableComponent MC(SimpleRefExpr, D);
11099 DSAStack->addMappableExpressionComponents(
11100 D, MC, /*WhereFoundClauseKind=*/OMPC_is_device_ptr);
11102 // Record the expression we've just processed.
11103 MVLI.ProcessedVarList.push_back(SimpleRefExpr);
11105 // Create a mappable component for the list item. List items in this clause
11106 // only need a component. We use a null declaration to signal fields in
11108 assert((isa<DeclRefExpr>(SimpleRefExpr) ||
11109 isa<CXXThisExpr>(cast<MemberExpr>(SimpleRefExpr)->getBase())) &&
11110 "Unexpected device pointer expression!");
11111 MVLI.VarBaseDeclarations.push_back(
11112 isa<DeclRefExpr>(SimpleRefExpr) ? D : nullptr);
11113 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
11114 MVLI.VarComponents.back().push_back(MC);
11117 if (MVLI.ProcessedVarList.empty())
11120 return OMPIsDevicePtrClause::Create(
11121 Context, StartLoc, LParenLoc, EndLoc, MVLI.ProcessedVarList,
11122 MVLI.VarBaseDeclarations, MVLI.VarComponents);