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.
121 DeclSAMapTy Threadprivates;
122 const FunctionScopeInfo *CurrentNonCapturingFunctionScope = nullptr;
123 SmallVector<std::pair<StackTy, const FunctionScopeInfo *>, 4> Stack;
124 /// \brief true, if check for DSA must be from parent directive, false, if
125 /// from current directive.
126 OpenMPClauseKind ClauseKindMode = OMPC_unknown;
128 bool ForceCapturing = false;
129 CriticalsWithHintsTy Criticals;
131 typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator;
133 DSAVarData getDSA(StackTy::reverse_iterator &Iter, ValueDecl *D);
135 /// \brief Checks if the variable is a local for OpenMP region.
136 bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter);
138 bool isStackEmpty() const {
139 return Stack.empty() ||
140 Stack.back().second != CurrentNonCapturingFunctionScope ||
141 Stack.back().first.empty();
145 explicit DSAStackTy(Sema &S) : SemaRef(S) {}
147 bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
148 void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }
150 bool isForceVarCapturing() const { return ForceCapturing; }
151 void setForceVarCapturing(bool V) { ForceCapturing = V; }
153 void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
154 Scope *CurScope, SourceLocation Loc) {
156 Stack.back().second != CurrentNonCapturingFunctionScope)
157 Stack.emplace_back(StackTy(), CurrentNonCapturingFunctionScope);
158 Stack.back().first.emplace_back(DKind, DirName, CurScope, Loc);
159 Stack.back().first.back().DefaultAttrLoc = Loc;
163 assert(!Stack.back().first.empty() &&
164 "Data-sharing attributes stack is empty!");
165 Stack.back().first.pop_back();
168 /// Start new OpenMP region stack in new non-capturing function.
169 void pushFunction() {
170 const FunctionScopeInfo *CurFnScope = SemaRef.getCurFunction();
171 assert(!isa<CapturingScopeInfo>(CurFnScope));
172 CurrentNonCapturingFunctionScope = CurFnScope;
174 /// Pop region stack for non-capturing function.
175 void popFunction(const FunctionScopeInfo *OldFSI) {
176 if (!Stack.empty() && Stack.back().second == OldFSI) {
177 assert(Stack.back().first.empty());
180 CurrentNonCapturingFunctionScope = nullptr;
181 for (const FunctionScopeInfo *FSI : llvm::reverse(SemaRef.FunctionScopes)) {
182 if (!isa<CapturingScopeInfo>(FSI)) {
183 CurrentNonCapturingFunctionScope = FSI;
189 void addCriticalWithHint(OMPCriticalDirective *D, llvm::APSInt Hint) {
190 Criticals[D->getDirectiveName().getAsString()] = std::make_pair(D, Hint);
192 const std::pair<OMPCriticalDirective *, llvm::APSInt>
193 getCriticalWithHint(const DeclarationNameInfo &Name) const {
194 auto I = Criticals.find(Name.getAsString());
195 if (I != Criticals.end())
197 return std::make_pair(nullptr, llvm::APSInt());
199 /// \brief If 'aligned' declaration for given variable \a D was not seen yet,
200 /// add it and return NULL; otherwise return previous occurrence's expression
202 Expr *addUniqueAligned(ValueDecl *D, Expr *NewDE);
204 /// \brief Register specified variable as loop control variable.
205 void addLoopControlVariable(ValueDecl *D, VarDecl *Capture);
206 /// \brief Check if the specified variable is a loop control variable for
208 /// \return The index of the loop control variable in the list of associated
209 /// for-loops (from outer to inner).
210 LCDeclInfo isLoopControlVariable(ValueDecl *D);
211 /// \brief Check if the specified variable is a loop control variable for
213 /// \return The index of the loop control variable in the list of associated
214 /// for-loops (from outer to inner).
215 LCDeclInfo isParentLoopControlVariable(ValueDecl *D);
216 /// \brief Get the loop control variable for the I-th loop (or nullptr) in
217 /// parent directive.
218 ValueDecl *getParentLoopControlVariable(unsigned I);
220 /// \brief Adds explicit data sharing attribute to the specified declaration.
221 void addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
222 DeclRefExpr *PrivateCopy = nullptr);
224 /// \brief Returns data sharing attributes from top of the stack for the
225 /// specified declaration.
226 DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
227 /// \brief Returns data-sharing attributes for the specified declaration.
228 DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent);
229 /// \brief Checks if the specified variables has data-sharing attributes which
230 /// match specified \a CPred predicate in any directive which matches \a DPred
232 DSAVarData hasDSA(ValueDecl *D,
233 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
234 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
236 /// \brief Checks if the specified variables has data-sharing attributes which
237 /// match specified \a CPred predicate in any innermost directive which
238 /// matches \a DPred predicate.
240 hasInnermostDSA(ValueDecl *D,
241 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
242 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
244 /// \brief Checks if the specified variables has explicit data-sharing
245 /// attributes which match specified \a CPred predicate at the specified
247 bool hasExplicitDSA(ValueDecl *D,
248 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
249 unsigned Level, bool NotLastprivate = false);
251 /// \brief Returns true if the directive at level \Level matches in the
252 /// specified \a DPred predicate.
253 bool hasExplicitDirective(
254 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
257 /// \brief Finds a directive which matches specified \a DPred predicate.
258 bool hasDirective(const llvm::function_ref<bool(OpenMPDirectiveKind,
259 const DeclarationNameInfo &,
260 SourceLocation)> &DPred,
263 /// \brief Returns currently analyzed directive.
264 OpenMPDirectiveKind getCurrentDirective() const {
265 return isStackEmpty() ? OMPD_unknown : Stack.back().first.back().Directive;
267 /// \brief Returns parent directive.
268 OpenMPDirectiveKind getParentDirective() const {
269 if (isStackEmpty() || Stack.back().first.size() == 1)
271 return std::next(Stack.back().first.rbegin())->Directive;
274 /// \brief Set default data sharing attribute to none.
275 void setDefaultDSANone(SourceLocation Loc) {
276 assert(!isStackEmpty());
277 Stack.back().first.back().DefaultAttr = DSA_none;
278 Stack.back().first.back().DefaultAttrLoc = Loc;
280 /// \brief Set default data sharing attribute to shared.
281 void setDefaultDSAShared(SourceLocation Loc) {
282 assert(!isStackEmpty());
283 Stack.back().first.back().DefaultAttr = DSA_shared;
284 Stack.back().first.back().DefaultAttrLoc = Loc;
287 DefaultDataSharingAttributes getDefaultDSA() const {
288 return isStackEmpty() ? DSA_unspecified
289 : Stack.back().first.back().DefaultAttr;
291 SourceLocation getDefaultDSALocation() const {
292 return isStackEmpty() ? SourceLocation()
293 : Stack.back().first.back().DefaultAttrLoc;
296 /// \brief Checks if the specified variable is a threadprivate.
297 bool isThreadPrivate(VarDecl *D) {
298 DSAVarData DVar = getTopDSA(D, false);
299 return isOpenMPThreadPrivate(DVar.CKind);
302 /// \brief Marks current region as ordered (it has an 'ordered' clause).
303 void setOrderedRegion(bool IsOrdered, Expr *Param) {
304 assert(!isStackEmpty());
305 Stack.back().first.back().OrderedRegion.setInt(IsOrdered);
306 Stack.back().first.back().OrderedRegion.setPointer(Param);
308 /// \brief Returns true, if parent region is ordered (has associated
309 /// 'ordered' clause), false - otherwise.
310 bool isParentOrderedRegion() const {
311 if (isStackEmpty() || Stack.back().first.size() == 1)
313 return std::next(Stack.back().first.rbegin())->OrderedRegion.getInt();
315 /// \brief Returns optional parameter for the ordered region.
316 Expr *getParentOrderedRegionParam() const {
317 if (isStackEmpty() || Stack.back().first.size() == 1)
319 return std::next(Stack.back().first.rbegin())->OrderedRegion.getPointer();
321 /// \brief Marks current region as nowait (it has a 'nowait' clause).
322 void setNowaitRegion(bool IsNowait = true) {
323 assert(!isStackEmpty());
324 Stack.back().first.back().NowaitRegion = IsNowait;
326 /// \brief Returns true, if parent region is nowait (has associated
327 /// 'nowait' clause), false - otherwise.
328 bool isParentNowaitRegion() const {
329 if (isStackEmpty() || Stack.back().first.size() == 1)
331 return std::next(Stack.back().first.rbegin())->NowaitRegion;
333 /// \brief Marks parent region as cancel region.
334 void setParentCancelRegion(bool Cancel = true) {
335 if (!isStackEmpty() && Stack.back().first.size() > 1) {
336 auto &StackElemRef = *std::next(Stack.back().first.rbegin());
337 StackElemRef.CancelRegion |= StackElemRef.CancelRegion || Cancel;
340 /// \brief Return true if current region has inner cancel construct.
341 bool isCancelRegion() const {
342 return isStackEmpty() ? false : Stack.back().first.back().CancelRegion;
345 /// \brief Set collapse value for the region.
346 void setAssociatedLoops(unsigned Val) {
347 assert(!isStackEmpty());
348 Stack.back().first.back().AssociatedLoops = Val;
350 /// \brief Return collapse value for region.
351 unsigned getAssociatedLoops() const {
352 return isStackEmpty() ? 0 : Stack.back().first.back().AssociatedLoops;
355 /// \brief Marks current target region as one with closely nested teams
357 void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
358 if (!isStackEmpty() && Stack.back().first.size() > 1) {
359 std::next(Stack.back().first.rbegin())->InnerTeamsRegionLoc =
363 /// \brief Returns true, if current region has closely nested teams region.
364 bool hasInnerTeamsRegion() const {
365 return getInnerTeamsRegionLoc().isValid();
367 /// \brief Returns location of the nested teams region (if any).
368 SourceLocation getInnerTeamsRegionLoc() const {
369 return isStackEmpty() ? SourceLocation()
370 : Stack.back().first.back().InnerTeamsRegionLoc;
373 Scope *getCurScope() const {
374 return isStackEmpty() ? nullptr : Stack.back().first.back().CurScope;
376 Scope *getCurScope() {
377 return isStackEmpty() ? nullptr : Stack.back().first.back().CurScope;
379 SourceLocation getConstructLoc() {
380 return isStackEmpty() ? SourceLocation()
381 : Stack.back().first.back().ConstructLoc;
384 /// Do the check specified in \a Check to all component lists and return true
385 /// if any issue is found.
386 bool checkMappableExprComponentListsForDecl(
387 ValueDecl *VD, bool CurrentRegionOnly,
388 const llvm::function_ref<
389 bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
390 OpenMPClauseKind)> &Check) {
393 auto SI = Stack.back().first.rbegin();
394 auto SE = Stack.back().first.rend();
399 if (CurrentRegionOnly) {
405 for (; SI != SE; ++SI) {
406 auto MI = SI->MappedExprComponents.find(VD);
407 if (MI != SI->MappedExprComponents.end())
408 for (auto &L : MI->second.Components)
409 if (Check(L, MI->second.Kind))
415 /// Create a new mappable expression component list associated with a given
416 /// declaration and initialize it with the provided list of components.
417 void addMappableExpressionComponents(
419 OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
420 OpenMPClauseKind WhereFoundClauseKind) {
421 assert(!isStackEmpty() &&
422 "Not expecting to retrieve components from a empty stack!");
423 auto &MEC = Stack.back().first.back().MappedExprComponents[VD];
424 // Create new entry and append the new components there.
425 MEC.Components.resize(MEC.Components.size() + 1);
426 MEC.Components.back().append(Components.begin(), Components.end());
427 MEC.Kind = WhereFoundClauseKind;
430 unsigned getNestingLevel() const {
431 assert(!isStackEmpty());
432 return Stack.back().first.size() - 1;
434 void addDoacrossDependClause(OMPDependClause *C, OperatorOffsetTy &OpsOffs) {
435 assert(!isStackEmpty() && Stack.back().first.size() > 1);
436 auto &StackElem = *std::next(Stack.back().first.rbegin());
437 assert(isOpenMPWorksharingDirective(StackElem.Directive));
438 StackElem.DoacrossDepends.insert({C, OpsOffs});
440 llvm::iterator_range<DoacrossDependMapTy::const_iterator>
441 getDoacrossDependClauses() const {
442 assert(!isStackEmpty());
443 auto &StackElem = Stack.back().first.back();
444 if (isOpenMPWorksharingDirective(StackElem.Directive)) {
445 auto &Ref = StackElem.DoacrossDepends;
446 return llvm::make_range(Ref.begin(), Ref.end());
448 return llvm::make_range(StackElem.DoacrossDepends.end(),
449 StackElem.DoacrossDepends.end());
452 bool isParallelOrTaskRegion(OpenMPDirectiveKind DKind) {
453 return isOpenMPParallelDirective(DKind) || isOpenMPTaskingDirective(DKind) ||
454 isOpenMPTeamsDirective(DKind) || DKind == OMPD_unknown;
458 static ValueDecl *getCanonicalDecl(ValueDecl *D) {
459 auto *VD = dyn_cast<VarDecl>(D);
460 auto *FD = dyn_cast<FieldDecl>(D);
462 VD = VD->getCanonicalDecl();
466 FD = FD->getCanonicalDecl();
472 DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator &Iter,
474 D = getCanonicalDecl(D);
475 auto *VD = dyn_cast<VarDecl>(D);
476 auto *FD = dyn_cast<FieldDecl>(D);
478 if (isStackEmpty() || Iter == Stack.back().first.rend()) {
479 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
480 // in a region but not in construct]
481 // File-scope or namespace-scope variables referenced in called routines
482 // in the region are shared unless they appear in a threadprivate
484 if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(D))
485 DVar.CKind = OMPC_shared;
487 // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
488 // in a region but not in construct]
489 // Variables with static storage duration that are declared in called
490 // routines in the region are shared.
491 if (VD && VD->hasGlobalStorage())
492 DVar.CKind = OMPC_shared;
494 // Non-static data members are shared by default.
496 DVar.CKind = OMPC_shared;
501 DVar.DKind = Iter->Directive;
502 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
503 // in a Construct, C/C++, predetermined, p.1]
504 // Variables with automatic storage duration that are declared in a scope
505 // inside the construct are private.
506 if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
507 (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
508 DVar.CKind = OMPC_private;
512 // Explicitly specified attributes and local variables with predetermined
514 if (Iter->SharingMap.count(D)) {
515 DVar.RefExpr = Iter->SharingMap[D].RefExpr.getPointer();
516 DVar.PrivateCopy = Iter->SharingMap[D].PrivateCopy;
517 DVar.CKind = Iter->SharingMap[D].Attributes;
518 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
522 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
523 // in a Construct, C/C++, implicitly determined, p.1]
524 // In a parallel or task construct, the data-sharing attributes of these
525 // variables are determined by the default clause, if present.
526 switch (Iter->DefaultAttr) {
528 DVar.CKind = OMPC_shared;
529 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
533 case DSA_unspecified:
534 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
535 // in a Construct, implicitly determined, p.2]
536 // In a parallel construct, if no default clause is present, these
537 // variables are shared.
538 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
539 if (isOpenMPParallelDirective(DVar.DKind) ||
540 isOpenMPTeamsDirective(DVar.DKind)) {
541 DVar.CKind = OMPC_shared;
545 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
546 // in a Construct, implicitly determined, p.4]
547 // In a task construct, if no default clause is present, a variable that in
548 // the enclosing context is determined to be shared by all implicit tasks
549 // bound to the current team is shared.
550 if (isOpenMPTaskingDirective(DVar.DKind)) {
552 auto I = Iter, E = Stack.back().first.rend();
555 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
556 // Referenced in a Construct, implicitly determined, p.6]
557 // In a task construct, if no default clause is present, a variable
558 // whose data-sharing attribute is not determined by the rules above is
560 DVarTemp = getDSA(I, D);
561 if (DVarTemp.CKind != OMPC_shared) {
562 DVar.RefExpr = nullptr;
563 DVar.CKind = OMPC_firstprivate;
566 } while (I != E && !isParallelOrTaskRegion(I->Directive));
568 (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
572 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
573 // in a Construct, implicitly determined, p.3]
574 // For constructs other than task, if no default clause is present, these
575 // variables inherit their data-sharing attributes from the enclosing
577 return getDSA(++Iter, D);
580 Expr *DSAStackTy::addUniqueAligned(ValueDecl *D, Expr *NewDE) {
581 assert(!isStackEmpty() && "Data sharing attributes stack is empty");
582 D = getCanonicalDecl(D);
583 auto &StackElem = Stack.back().first.back();
584 auto It = StackElem.AlignedMap.find(D);
585 if (It == StackElem.AlignedMap.end()) {
586 assert(NewDE && "Unexpected nullptr expr to be added into aligned map");
587 StackElem.AlignedMap[D] = NewDE;
590 assert(It->second && "Unexpected nullptr expr in the aligned map");
596 void DSAStackTy::addLoopControlVariable(ValueDecl *D, VarDecl *Capture) {
597 assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
598 D = getCanonicalDecl(D);
599 auto &StackElem = Stack.back().first.back();
600 StackElem.LCVMap.insert(
601 {D, LCDeclInfo(StackElem.LCVMap.size() + 1, Capture)});
604 DSAStackTy::LCDeclInfo DSAStackTy::isLoopControlVariable(ValueDecl *D) {
605 assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
606 D = getCanonicalDecl(D);
607 auto &StackElem = Stack.back().first.back();
608 auto It = StackElem.LCVMap.find(D);
609 if (It != StackElem.LCVMap.end())
614 DSAStackTy::LCDeclInfo DSAStackTy::isParentLoopControlVariable(ValueDecl *D) {
615 assert(!isStackEmpty() && Stack.back().first.size() > 1 &&
616 "Data-sharing attributes stack is empty");
617 D = getCanonicalDecl(D);
618 auto &StackElem = *std::next(Stack.back().first.rbegin());
619 auto It = StackElem.LCVMap.find(D);
620 if (It != StackElem.LCVMap.end())
625 ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) {
626 assert(!isStackEmpty() && Stack.back().first.size() > 1 &&
627 "Data-sharing attributes stack is empty");
628 auto &StackElem = *std::next(Stack.back().first.rbegin());
629 if (StackElem.LCVMap.size() < I)
631 for (auto &Pair : StackElem.LCVMap)
632 if (Pair.second.first == I)
637 void DSAStackTy::addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
638 DeclRefExpr *PrivateCopy) {
639 D = getCanonicalDecl(D);
640 if (A == OMPC_threadprivate) {
641 auto &Data = Threadprivates[D];
643 Data.RefExpr.setPointer(E);
644 Data.PrivateCopy = nullptr;
646 assert(!isStackEmpty() && "Data-sharing attributes stack is empty");
647 auto &Data = Stack.back().first.back().SharingMap[D];
648 assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
649 (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||
650 (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||
651 (isLoopControlVariable(D).first && A == OMPC_private));
652 if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
653 Data.RefExpr.setInt(/*IntVal=*/true);
656 const bool IsLastprivate =
657 A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
659 Data.RefExpr.setPointerAndInt(E, IsLastprivate);
660 Data.PrivateCopy = PrivateCopy;
662 auto &Data = Stack.back().first.back().SharingMap[PrivateCopy->getDecl()];
664 Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
665 Data.PrivateCopy = nullptr;
670 bool DSAStackTy::isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter) {
671 D = D->getCanonicalDecl();
672 if (!isStackEmpty() && Stack.back().first.size() > 1) {
673 reverse_iterator I = Iter, E = Stack.back().first.rend();
674 Scope *TopScope = nullptr;
675 while (I != E && !isParallelOrTaskRegion(I->Directive))
679 TopScope = I->CurScope ? I->CurScope->getParent() : nullptr;
680 Scope *CurScope = getCurScope();
681 while (CurScope != TopScope && !CurScope->isDeclScope(D))
682 CurScope = CurScope->getParent();
683 return CurScope != TopScope;
688 /// \brief Build a variable declaration for OpenMP loop iteration variable.
689 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
690 StringRef Name, const AttrVec *Attrs = nullptr) {
691 DeclContext *DC = SemaRef.CurContext;
692 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
693 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
695 VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
697 for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
705 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
707 bool RefersToCapture = false) {
709 D->markUsed(S.Context);
710 return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
711 SourceLocation(), D, RefersToCapture, Loc, Ty,
715 DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D, bool FromParent) {
716 D = getCanonicalDecl(D);
719 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
720 // in a Construct, C/C++, predetermined, p.1]
721 // Variables appearing in threadprivate directives are threadprivate.
722 auto *VD = dyn_cast<VarDecl>(D);
723 if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
724 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
725 SemaRef.getLangOpts().OpenMPUseTLS &&
726 SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
727 (VD && VD->getStorageClass() == SC_Register &&
728 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
729 addDSA(D, buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
733 auto TI = Threadprivates.find(D);
734 if (TI != Threadprivates.end()) {
735 DVar.RefExpr = TI->getSecond().RefExpr.getPointer();
736 DVar.CKind = OMPC_threadprivate;
741 // Not in OpenMP execution region and top scope was already checked.
744 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
745 // in a Construct, C/C++, predetermined, p.4]
746 // Static data members are shared.
747 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
748 // in a Construct, C/C++, predetermined, p.7]
749 // Variables with static storage duration that are declared in a scope
750 // inside the construct are shared.
751 auto &&MatchesAlways = [](OpenMPDirectiveKind) -> bool { return true; };
752 if (VD && VD->isStaticDataMember()) {
753 DSAVarData DVarTemp = hasDSA(D, isOpenMPPrivate, MatchesAlways, FromParent);
754 if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
757 DVar.CKind = OMPC_shared;
761 QualType Type = D->getType().getNonReferenceType().getCanonicalType();
762 bool IsConstant = Type.isConstant(SemaRef.getASTContext());
763 Type = SemaRef.getASTContext().getBaseElementType(Type);
764 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
765 // in a Construct, C/C++, predetermined, p.6]
766 // Variables with const qualified type having no mutable member are
769 SemaRef.getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr;
770 if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
771 if (auto *CTD = CTSD->getSpecializedTemplate())
772 RD = CTD->getTemplatedDecl();
774 !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() &&
775 RD->hasMutableFields())) {
776 // Variables with const-qualified type having no mutable member may be
777 // listed in a firstprivate clause, even if they are static data members.
778 DSAVarData DVarTemp = hasDSA(
779 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_firstprivate; },
780 MatchesAlways, FromParent);
781 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr)
784 DVar.CKind = OMPC_shared;
788 // Explicitly specified attributes and local variables with predetermined
790 auto StartI = std::next(Stack.back().first.rbegin());
791 auto EndI = Stack.back().first.rend();
792 if (FromParent && StartI != EndI)
793 StartI = std::next(StartI);
794 auto I = std::prev(StartI);
795 if (I->SharingMap.count(D)) {
796 DVar.RefExpr = I->SharingMap[D].RefExpr.getPointer();
797 DVar.PrivateCopy = I->SharingMap[D].PrivateCopy;
798 DVar.CKind = I->SharingMap[D].Attributes;
799 DVar.ImplicitDSALoc = I->DefaultAttrLoc;
805 DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
807 if (isStackEmpty()) {
808 StackTy::reverse_iterator I;
811 D = getCanonicalDecl(D);
812 auto StartI = Stack.back().first.rbegin();
813 auto EndI = Stack.back().first.rend();
814 if (FromParent && StartI != EndI)
815 StartI = std::next(StartI);
816 return getDSA(StartI, D);
819 DSAStackTy::DSAVarData
820 DSAStackTy::hasDSA(ValueDecl *D,
821 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
822 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
826 D = getCanonicalDecl(D);
827 auto I = (FromParent && Stack.back().first.size() > 1)
828 ? std::next(Stack.back().first.rbegin())
829 : Stack.back().first.rbegin();
830 auto EndI = Stack.back().first.rend();
831 while (std::distance(I, EndI) > 1) {
833 if (!DPred(I->Directive) && !isParallelOrTaskRegion(I->Directive))
835 DSAVarData DVar = getDSA(I, D);
836 if (CPred(DVar.CKind))
842 DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
843 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
844 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
848 D = getCanonicalDecl(D);
849 auto StartI = std::next(Stack.back().first.rbegin());
850 auto EndI = Stack.back().first.rend();
851 if (FromParent && StartI != EndI)
852 StartI = std::next(StartI);
853 if (StartI == EndI || !DPred(StartI->Directive))
855 DSAVarData DVar = getDSA(StartI, D);
856 return CPred(DVar.CKind) ? DVar : DSAVarData();
859 bool DSAStackTy::hasExplicitDSA(
860 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
861 unsigned Level, bool NotLastprivate) {
862 if (CPred(ClauseKindMode))
866 D = getCanonicalDecl(D);
867 auto StartI = Stack.back().first.begin();
868 auto EndI = Stack.back().first.end();
869 if (std::distance(StartI, EndI) <= (int)Level)
871 std::advance(StartI, Level);
872 return (StartI->SharingMap.count(D) > 0) &&
873 StartI->SharingMap[D].RefExpr.getPointer() &&
874 CPred(StartI->SharingMap[D].Attributes) &&
875 (!NotLastprivate || !StartI->SharingMap[D].RefExpr.getInt());
878 bool DSAStackTy::hasExplicitDirective(
879 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
883 auto StartI = Stack.back().first.begin();
884 auto EndI = Stack.back().first.end();
885 if (std::distance(StartI, EndI) <= (int)Level)
887 std::advance(StartI, Level);
888 return DPred(StartI->Directive);
891 bool DSAStackTy::hasDirective(
892 const llvm::function_ref<bool(OpenMPDirectiveKind,
893 const DeclarationNameInfo &, SourceLocation)>
896 // We look only in the enclosing region.
899 auto StartI = std::next(Stack.back().first.rbegin());
900 auto EndI = Stack.back().first.rend();
901 if (FromParent && StartI != EndI)
902 StartI = std::next(StartI);
903 for (auto I = StartI, EE = EndI; I != EE; ++I) {
904 if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc))
910 void Sema::InitDataSharingAttributesStack() {
911 VarDataSharingAttributesStack = new DSAStackTy(*this);
914 #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack)
916 void Sema::pushOpenMPFunctionRegion() {
917 DSAStack->pushFunction();
920 void Sema::popOpenMPFunctionRegion(const FunctionScopeInfo *OldFSI) {
921 DSAStack->popFunction(OldFSI);
924 bool Sema::IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level) {
925 assert(LangOpts.OpenMP && "OpenMP is not allowed");
927 auto &Ctx = getASTContext();
930 // Find the directive that is associated with the provided scope.
931 auto Ty = D->getType();
933 if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) {
934 // This table summarizes how a given variable should be passed to the device
935 // given its type and the clauses where it appears. This table is based on
936 // the description in OpenMP 4.5 [2.10.4, target Construct] and
937 // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses].
939 // =========================================================================
940 // | type | defaultmap | pvt | first | is_device_ptr | map | res. |
941 // | |(tofrom:scalar)| | pvt | | | |
942 // =========================================================================
943 // | scl | | | | - | | bycopy|
944 // | scl | | - | x | - | - | bycopy|
945 // | scl | | x | - | - | - | null |
946 // | scl | x | | | - | | byref |
947 // | scl | x | - | x | - | - | bycopy|
948 // | scl | x | x | - | - | - | null |
949 // | scl | | - | - | - | x | byref |
950 // | scl | x | - | - | - | x | byref |
952 // | agg | n.a. | | | - | | byref |
953 // | agg | n.a. | - | x | - | - | byref |
954 // | agg | n.a. | x | - | - | - | null |
955 // | agg | n.a. | - | - | - | x | byref |
956 // | agg | n.a. | - | - | - | x[] | byref |
958 // | ptr | n.a. | | | - | | bycopy|
959 // | ptr | n.a. | - | x | - | - | bycopy|
960 // | ptr | n.a. | x | - | - | - | null |
961 // | ptr | n.a. | - | - | - | x | byref |
962 // | ptr | n.a. | - | - | - | x[] | bycopy|
963 // | ptr | n.a. | - | - | x | | bycopy|
964 // | ptr | n.a. | - | - | x | x | bycopy|
965 // | ptr | n.a. | - | - | x | x[] | bycopy|
966 // =========================================================================
972 // - - invalid in this combination
973 // [] - mapped with an array section
974 // byref - should be mapped by reference
975 // byval - should be mapped by value
976 // null - initialize a local variable to null on the device
979 // - All scalar declarations that show up in a map clause have to be passed
980 // by reference, because they may have been mapped in the enclosing data
982 // - If the scalar value does not fit the size of uintptr, it has to be
983 // passed by reference, regardless the result in the table above.
984 // - For pointers mapped by value that have either an implicit map or an
985 // array section, the runtime library may pass the NULL value to the
986 // device instead of the value passed to it by the compiler.
988 if (Ty->isReferenceType())
989 Ty = Ty->castAs<ReferenceType>()->getPointeeType();
991 // Locate map clauses and see if the variable being captured is referred to
992 // in any of those clauses. Here we only care about variables, not fields,
993 // because fields are part of aggregates.
994 bool IsVariableUsedInMapClause = false;
995 bool IsVariableAssociatedWithSection = false;
997 DSAStack->checkMappableExprComponentListsForDecl(
998 D, /*CurrentRegionOnly=*/true,
999 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
1001 OpenMPClauseKind WhereFoundClauseKind) {
1002 // Only the map clause information influences how a variable is
1003 // captured. E.g. is_device_ptr does not require changing the default
1005 if (WhereFoundClauseKind != OMPC_map)
1008 auto EI = MapExprComponents.rbegin();
1009 auto EE = MapExprComponents.rend();
1011 assert(EI != EE && "Invalid map expression!");
1013 if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
1014 IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
1020 if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
1021 isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
1022 isa<MemberExpr>(EI->getAssociatedExpression())) {
1023 IsVariableAssociatedWithSection = true;
1024 // There is nothing more we need to know about this variable.
1028 // Keep looking for more map info.
1032 if (IsVariableUsedInMapClause) {
1033 // If variable is identified in a map clause it is always captured by
1034 // reference except if it is a pointer that is dereferenced somehow.
1035 IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
1037 // By default, all the data that has a scalar type is mapped by copy.
1038 IsByRef = !Ty->isScalarType();
1042 if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
1043 IsByRef = !DSAStack->hasExplicitDSA(
1044 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_firstprivate; },
1045 Level, /*NotLastprivate=*/true);
1048 // When passing data by copy, we need to make sure it fits the uintptr size
1049 // and alignment, because the runtime library only deals with uintptr types.
1050 // If it does not fit the uintptr size, we need to pass the data by reference
1053 (Ctx.getTypeSizeInChars(Ty) >
1054 Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
1055 Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
1062 unsigned Sema::getOpenMPNestingLevel() const {
1063 assert(getLangOpts().OpenMP);
1064 return DSAStack->getNestingLevel();
1067 VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) {
1068 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1069 D = getCanonicalDecl(D);
1071 // If we are attempting to capture a global variable in a directive with
1072 // 'target' we return true so that this global is also mapped to the device.
1074 // FIXME: If the declaration is enclosed in a 'declare target' directive,
1075 // then it should not be captured. Therefore, an extra check has to be
1076 // inserted here once support for 'declare target' is added.
1078 auto *VD = dyn_cast<VarDecl>(D);
1079 if (VD && !VD->hasLocalStorage()) {
1080 if (DSAStack->getCurrentDirective() == OMPD_target &&
1081 !DSAStack->isClauseParsingMode())
1083 if (DSAStack->hasDirective(
1084 [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
1085 SourceLocation) -> bool {
1086 return isOpenMPTargetExecutionDirective(K);
1092 if (DSAStack->getCurrentDirective() != OMPD_unknown &&
1093 (!DSAStack->isClauseParsingMode() ||
1094 DSAStack->getParentDirective() != OMPD_unknown)) {
1095 auto &&Info = DSAStack->isLoopControlVariable(D);
1097 (VD && VD->hasLocalStorage() &&
1098 isParallelOrTaskRegion(DSAStack->getCurrentDirective())) ||
1099 (VD && DSAStack->isForceVarCapturing()))
1100 return VD ? VD : Info.second;
1101 auto DVarPrivate = DSAStack->getTopDSA(D, DSAStack->isClauseParsingMode());
1102 if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind))
1103 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1104 DVarPrivate = DSAStack->hasDSA(
1105 D, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
1106 DSAStack->isClauseParsingMode());
1107 if (DVarPrivate.CKind != OMPC_unknown)
1108 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1113 bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) {
1114 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1115 return DSAStack->hasExplicitDSA(
1116 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level);
1119 bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) {
1120 assert(LangOpts.OpenMP && "OpenMP is not allowed");
1121 // Return true if the current level is no longer enclosed in a target region.
1123 auto *VD = dyn_cast<VarDecl>(D);
1124 return VD && !VD->hasLocalStorage() &&
1125 DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
1129 void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; }
1131 void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
1132 const DeclarationNameInfo &DirName,
1133 Scope *CurScope, SourceLocation Loc) {
1134 DSAStack->push(DKind, DirName, CurScope, Loc);
1135 PushExpressionEvaluationContext(
1136 ExpressionEvaluationContext::PotentiallyEvaluated);
1139 void Sema::StartOpenMPClause(OpenMPClauseKind K) {
1140 DSAStack->setClauseParsingMode(K);
1143 void Sema::EndOpenMPClause() {
1144 DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown);
1147 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
1148 // OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
1149 // A variable of class type (or array thereof) that appears in a lastprivate
1150 // clause requires an accessible, unambiguous default constructor for the
1151 // class type, unless the list item is also specified in a firstprivate
1153 if (auto *D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
1154 for (auto *C : D->clauses()) {
1155 if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
1156 SmallVector<Expr *, 8> PrivateCopies;
1157 for (auto *DE : Clause->varlists()) {
1158 if (DE->isValueDependent() || DE->isTypeDependent()) {
1159 PrivateCopies.push_back(nullptr);
1162 auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
1163 VarDecl *VD = cast<VarDecl>(DRE->getDecl());
1164 QualType Type = VD->getType().getNonReferenceType();
1165 auto DVar = DSAStack->getTopDSA(VD, false);
1166 if (DVar.CKind == OMPC_lastprivate) {
1167 // Generate helper private variable and initialize it with the
1168 // default value. The address of the original variable is replaced
1169 // by the address of the new private variable in CodeGen. This new
1170 // variable is not added to IdResolver, so the code in the OpenMP
1171 // region uses original variable for proper diagnostics.
1172 auto *VDPrivate = buildVarDecl(
1173 *this, DE->getExprLoc(), Type.getUnqualifiedType(),
1174 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr);
1175 ActOnUninitializedDecl(VDPrivate);
1176 if (VDPrivate->isInvalidDecl())
1178 PrivateCopies.push_back(buildDeclRefExpr(
1179 *this, VDPrivate, DE->getType(), DE->getExprLoc()));
1181 // The variable is also a firstprivate, so initialization sequence
1182 // for private copy is generated already.
1183 PrivateCopies.push_back(nullptr);
1186 // Set initializers to private copies if no errors were found.
1187 if (PrivateCopies.size() == Clause->varlist_size())
1188 Clause->setPrivateCopies(PrivateCopies);
1194 DiscardCleanupsInEvaluationContext();
1195 PopExpressionEvaluationContext();
1198 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1199 Expr *NumIterations, Sema &SemaRef,
1200 Scope *S, DSAStackTy *Stack);
1204 class VarDeclFilterCCC : public CorrectionCandidateCallback {
1209 explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
1210 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1211 NamedDecl *ND = Candidate.getCorrectionDecl();
1212 if (auto *VD = dyn_cast_or_null<VarDecl>(ND)) {
1213 return VD->hasGlobalStorage() &&
1214 SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1215 SemaRef.getCurScope());
1221 class VarOrFuncDeclFilterCCC : public CorrectionCandidateCallback {
1226 explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
1227 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1228 NamedDecl *ND = Candidate.getCorrectionDecl();
1229 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
1230 return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1231 SemaRef.getCurScope());
1239 ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
1240 CXXScopeSpec &ScopeSpec,
1241 const DeclarationNameInfo &Id) {
1242 LookupResult Lookup(*this, Id, LookupOrdinaryName);
1243 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
1245 if (Lookup.isAmbiguous())
1249 if (!Lookup.isSingleResult()) {
1250 if (TypoCorrection Corrected = CorrectTypo(
1251 Id, LookupOrdinaryName, CurScope, nullptr,
1252 llvm::make_unique<VarDeclFilterCCC>(*this), CTK_ErrorRecovery)) {
1253 diagnoseTypo(Corrected,
1254 PDiag(Lookup.empty()
1255 ? diag::err_undeclared_var_use_suggest
1256 : diag::err_omp_expected_var_arg_suggest)
1258 VD = Corrected.getCorrectionDeclAs<VarDecl>();
1260 Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
1261 : diag::err_omp_expected_var_arg)
1266 if (!(VD = Lookup.getAsSingle<VarDecl>())) {
1267 Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
1268 Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
1272 Lookup.suppressDiagnostics();
1274 // OpenMP [2.9.2, Syntax, C/C++]
1275 // Variables must be file-scope, namespace-scope, or static block-scope.
1276 if (!VD->hasGlobalStorage()) {
1277 Diag(Id.getLoc(), diag::err_omp_global_var_arg)
1278 << getOpenMPDirectiveName(OMPD_threadprivate) << !VD->isStaticLocal();
1280 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1281 Diag(VD->getLocation(),
1282 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1287 VarDecl *CanonicalVD = VD->getCanonicalDecl();
1288 NamedDecl *ND = cast<NamedDecl>(CanonicalVD);
1289 // OpenMP [2.9.2, Restrictions, C/C++, p.2]
1290 // A threadprivate directive for file-scope variables must appear outside
1291 // any definition or declaration.
1292 if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
1293 !getCurLexicalContext()->isTranslationUnit()) {
1294 Diag(Id.getLoc(), diag::err_omp_var_scope)
1295 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1297 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1298 Diag(VD->getLocation(),
1299 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1303 // OpenMP [2.9.2, Restrictions, C/C++, p.3]
1304 // A threadprivate directive for static class member variables must appear
1305 // in the class definition, in the same scope in which the member
1306 // variables are declared.
1307 if (CanonicalVD->isStaticDataMember() &&
1308 !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
1309 Diag(Id.getLoc(), diag::err_omp_var_scope)
1310 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1312 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1313 Diag(VD->getLocation(),
1314 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1318 // OpenMP [2.9.2, Restrictions, C/C++, p.4]
1319 // A threadprivate directive for namespace-scope variables must appear
1320 // outside any definition or declaration other than the namespace
1321 // definition itself.
1322 if (CanonicalVD->getDeclContext()->isNamespace() &&
1323 (!getCurLexicalContext()->isFileContext() ||
1324 !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
1325 Diag(Id.getLoc(), diag::err_omp_var_scope)
1326 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1328 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1329 Diag(VD->getLocation(),
1330 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1334 // OpenMP [2.9.2, Restrictions, C/C++, p.6]
1335 // A threadprivate directive for static block-scope variables must appear
1336 // in the scope of the variable and not in a nested scope.
1337 if (CanonicalVD->isStaticLocal() && CurScope &&
1338 !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
1339 Diag(Id.getLoc(), diag::err_omp_var_scope)
1340 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1342 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1343 Diag(VD->getLocation(),
1344 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1349 // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
1350 // A threadprivate directive must lexically precede all references to any
1351 // of the variables in its list.
1352 if (VD->isUsed() && !DSAStack->isThreadPrivate(VD)) {
1353 Diag(Id.getLoc(), diag::err_omp_var_used)
1354 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1358 QualType ExprType = VD->getType().getNonReferenceType();
1359 return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
1360 SourceLocation(), VD,
1361 /*RefersToEnclosingVariableOrCapture=*/false,
1362 Id.getLoc(), ExprType, VK_LValue);
1365 Sema::DeclGroupPtrTy
1366 Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
1367 ArrayRef<Expr *> VarList) {
1368 if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
1369 CurContext->addDecl(D);
1370 return DeclGroupPtrTy::make(DeclGroupRef(D));
1376 class LocalVarRefChecker : public ConstStmtVisitor<LocalVarRefChecker, bool> {
1380 bool VisitDeclRefExpr(const DeclRefExpr *E) {
1381 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1382 if (VD->hasLocalStorage()) {
1383 SemaRef.Diag(E->getLocStart(),
1384 diag::err_omp_local_var_in_threadprivate_init)
1385 << E->getSourceRange();
1386 SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
1387 << VD << VD->getSourceRange();
1393 bool VisitStmt(const Stmt *S) {
1394 for (auto Child : S->children()) {
1395 if (Child && Visit(Child))
1400 explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
1404 OMPThreadPrivateDecl *
1405 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
1406 SmallVector<Expr *, 8> Vars;
1407 for (auto &RefExpr : VarList) {
1408 DeclRefExpr *DE = cast<DeclRefExpr>(RefExpr);
1409 VarDecl *VD = cast<VarDecl>(DE->getDecl());
1410 SourceLocation ILoc = DE->getExprLoc();
1412 // Mark variable as used.
1413 VD->setReferenced();
1414 VD->markUsed(Context);
1416 QualType QType = VD->getType();
1417 if (QType->isDependentType() || QType->isInstantiationDependentType()) {
1418 // It will be analyzed later.
1423 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1424 // A threadprivate variable must not have an incomplete type.
1425 if (RequireCompleteType(ILoc, VD->getType(),
1426 diag::err_omp_threadprivate_incomplete_type)) {
1430 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1431 // A threadprivate variable must not have a reference type.
1432 if (VD->getType()->isReferenceType()) {
1433 Diag(ILoc, diag::err_omp_ref_type_arg)
1434 << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
1436 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1437 Diag(VD->getLocation(),
1438 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1443 // Check if this is a TLS variable. If TLS is not being supported, produce
1444 // the corresponding diagnostic.
1445 if ((VD->getTLSKind() != VarDecl::TLS_None &&
1446 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
1447 getLangOpts().OpenMPUseTLS &&
1448 getASTContext().getTargetInfo().isTLSSupported())) ||
1449 (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
1450 !VD->isLocalVarDecl())) {
1451 Diag(ILoc, diag::err_omp_var_thread_local)
1452 << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
1454 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1455 Diag(VD->getLocation(),
1456 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1461 // Check if initial value of threadprivate variable reference variable with
1462 // local storage (it is not supported by runtime).
1463 if (auto Init = VD->getAnyInitializer()) {
1464 LocalVarRefChecker Checker(*this);
1465 if (Checker.Visit(Init))
1469 Vars.push_back(RefExpr);
1470 DSAStack->addDSA(VD, DE, OMPC_threadprivate);
1471 VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
1472 Context, SourceRange(Loc, Loc)));
1473 if (auto *ML = Context.getASTMutationListener())
1474 ML->DeclarationMarkedOpenMPThreadPrivate(VD);
1476 OMPThreadPrivateDecl *D = nullptr;
1477 if (!Vars.empty()) {
1478 D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
1480 D->setAccess(AS_public);
1485 static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack,
1486 const ValueDecl *D, DSAStackTy::DSAVarData DVar,
1487 bool IsLoopIterVar = false) {
1489 SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
1490 << getOpenMPClauseName(DVar.CKind);
1494 PDSA_StaticMemberShared,
1495 PDSA_StaticLocalVarShared,
1496 PDSA_LoopIterVarPrivate,
1497 PDSA_LoopIterVarLinear,
1498 PDSA_LoopIterVarLastprivate,
1499 PDSA_ConstVarShared,
1500 PDSA_GlobalVarShared,
1501 PDSA_TaskVarFirstprivate,
1502 PDSA_LocalVarPrivate,
1504 } Reason = PDSA_Implicit;
1505 bool ReportHint = false;
1506 auto ReportLoc = D->getLocation();
1507 auto *VD = dyn_cast<VarDecl>(D);
1508 if (IsLoopIterVar) {
1509 if (DVar.CKind == OMPC_private)
1510 Reason = PDSA_LoopIterVarPrivate;
1511 else if (DVar.CKind == OMPC_lastprivate)
1512 Reason = PDSA_LoopIterVarLastprivate;
1514 Reason = PDSA_LoopIterVarLinear;
1515 } else if (isOpenMPTaskingDirective(DVar.DKind) &&
1516 DVar.CKind == OMPC_firstprivate) {
1517 Reason = PDSA_TaskVarFirstprivate;
1518 ReportLoc = DVar.ImplicitDSALoc;
1519 } else if (VD && VD->isStaticLocal())
1520 Reason = PDSA_StaticLocalVarShared;
1521 else if (VD && VD->isStaticDataMember())
1522 Reason = PDSA_StaticMemberShared;
1523 else if (VD && VD->isFileVarDecl())
1524 Reason = PDSA_GlobalVarShared;
1525 else if (D->getType().isConstant(SemaRef.getASTContext()))
1526 Reason = PDSA_ConstVarShared;
1527 else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
1529 Reason = PDSA_LocalVarPrivate;
1531 if (Reason != PDSA_Implicit) {
1532 SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
1533 << Reason << ReportHint
1534 << getOpenMPDirectiveName(Stack->getCurrentDirective());
1535 } else if (DVar.ImplicitDSALoc.isValid()) {
1536 SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
1537 << getOpenMPClauseName(DVar.CKind);
1542 class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> {
1547 llvm::SmallVector<Expr *, 8> ImplicitFirstprivate;
1548 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
1551 void VisitDeclRefExpr(DeclRefExpr *E) {
1552 if (E->isTypeDependent() || E->isValueDependent() ||
1553 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1555 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1556 // Skip internally declared variables.
1557 if (VD->isLocalVarDecl() && !CS->capturesVariable(VD))
1560 auto DVar = Stack->getTopDSA(VD, false);
1561 // Check if the variable has explicit DSA set and stop analysis if it so.
1565 auto ELoc = E->getExprLoc();
1566 auto DKind = Stack->getCurrentDirective();
1567 // The default(none) clause requires that each variable that is referenced
1568 // in the construct, and does not have a predetermined data-sharing
1569 // attribute, must have its data-sharing attribute explicitly determined
1570 // by being listed in a data-sharing attribute clause.
1571 if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none &&
1572 isParallelOrTaskRegion(DKind) &&
1573 VarsWithInheritedDSA.count(VD) == 0) {
1574 VarsWithInheritedDSA[VD] = E;
1578 // OpenMP [2.9.3.6, Restrictions, p.2]
1579 // A list item that appears in a reduction clause of the innermost
1580 // enclosing worksharing or parallel construct may not be accessed in an
1582 DVar = Stack->hasInnermostDSA(
1583 VD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1584 [](OpenMPDirectiveKind K) -> bool {
1585 return isOpenMPParallelDirective(K) ||
1586 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
1589 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1591 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1592 ReportOriginalDSA(SemaRef, Stack, VD, DVar);
1596 // Define implicit data-sharing attributes for task.
1597 DVar = Stack->getImplicitDSA(VD, false);
1598 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1599 !Stack->isLoopControlVariable(VD).first)
1600 ImplicitFirstprivate.push_back(E);
1603 void VisitMemberExpr(MemberExpr *E) {
1604 if (E->isTypeDependent() || E->isValueDependent() ||
1605 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1607 if (isa<CXXThisExpr>(E->getBase()->IgnoreParens())) {
1608 if (auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
1609 auto DVar = Stack->getTopDSA(FD, false);
1610 // Check if the variable has explicit DSA set and stop analysis if it
1615 auto ELoc = E->getExprLoc();
1616 auto DKind = Stack->getCurrentDirective();
1617 // OpenMP [2.9.3.6, Restrictions, p.2]
1618 // A list item that appears in a reduction clause of the innermost
1619 // enclosing worksharing or parallel construct may not be accessed in
1620 // an explicit task.
1621 DVar = Stack->hasInnermostDSA(
1622 FD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1623 [](OpenMPDirectiveKind K) -> bool {
1624 return isOpenMPParallelDirective(K) ||
1625 isOpenMPWorksharingDirective(K) ||
1626 isOpenMPTeamsDirective(K);
1629 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1631 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1632 ReportOriginalDSA(SemaRef, Stack, FD, DVar);
1636 // Define implicit data-sharing attributes for task.
1637 DVar = Stack->getImplicitDSA(FD, false);
1638 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1639 !Stack->isLoopControlVariable(FD).first)
1640 ImplicitFirstprivate.push_back(E);
1643 Visit(E->getBase());
1645 void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
1646 for (auto *C : S->clauses()) {
1647 // Skip analysis of arguments of implicitly defined firstprivate clause
1648 // for task directives.
1649 if (C && (!isa<OMPFirstprivateClause>(C) || C->getLocStart().isValid()))
1650 for (auto *CC : C->children()) {
1656 void VisitStmt(Stmt *S) {
1657 for (auto *C : S->children()) {
1658 if (C && !isa<OMPExecutableDirective>(C))
1663 bool isErrorFound() { return ErrorFound; }
1664 ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; }
1665 llvm::DenseMap<ValueDecl *, Expr *> &getVarsWithInheritedDSA() {
1666 return VarsWithInheritedDSA;
1669 DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
1670 : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {}
1674 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
1677 case OMPD_parallel_for:
1678 case OMPD_parallel_for_simd:
1679 case OMPD_parallel_sections:
1681 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1682 QualType KmpInt32PtrTy =
1683 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1684 Sema::CapturedParamNameType Params[] = {
1685 std::make_pair(".global_tid.", KmpInt32PtrTy),
1686 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1687 std::make_pair(StringRef(), QualType()) // __context with shared vars
1689 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1693 case OMPD_target_teams:
1694 case OMPD_target_parallel: {
1695 Sema::CapturedParamNameType ParamsTarget[] = {
1696 std::make_pair(StringRef(), QualType()) // __context with shared vars
1698 // Start a captured region for 'target' with no implicit parameters.
1699 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1701 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1702 QualType KmpInt32PtrTy =
1703 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1704 Sema::CapturedParamNameType ParamsTeamsOrParallel[] = {
1705 std::make_pair(".global_tid.", KmpInt32PtrTy),
1706 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1707 std::make_pair(StringRef(), QualType()) // __context with shared vars
1709 // Start a captured region for 'teams' or 'parallel'. Both regions have
1710 // the same implicit parameters.
1711 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1712 ParamsTeamsOrParallel);
1723 case OMPD_taskgroup:
1724 case OMPD_distribute:
1727 case OMPD_target_data:
1729 case OMPD_target_parallel_for:
1730 case OMPD_target_parallel_for_simd:
1731 case OMPD_target_simd: {
1732 Sema::CapturedParamNameType Params[] = {
1733 std::make_pair(StringRef(), QualType()) // __context with shared vars
1735 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1740 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1741 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1742 FunctionProtoType::ExtProtoInfo EPI;
1743 EPI.Variadic = true;
1744 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1745 Sema::CapturedParamNameType Params[] = {
1746 std::make_pair(".global_tid.", KmpInt32Ty),
1747 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1748 std::make_pair(".privates.", Context.VoidPtrTy.withConst()),
1749 std::make_pair(".copy_fn.",
1750 Context.getPointerType(CopyFnType).withConst()),
1751 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1752 std::make_pair(StringRef(), QualType()) // __context with shared vars
1754 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1756 // Mark this captured region as inlined, because we don't use outlined
1757 // function directly.
1758 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1759 AlwaysInlineAttr::CreateImplicit(
1760 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1764 case OMPD_taskloop_simd: {
1765 QualType KmpInt32Ty =
1766 Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
1767 QualType KmpUInt64Ty =
1768 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
1769 QualType KmpInt64Ty =
1770 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
1771 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1772 FunctionProtoType::ExtProtoInfo EPI;
1773 EPI.Variadic = true;
1774 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1775 Sema::CapturedParamNameType Params[] = {
1776 std::make_pair(".global_tid.", KmpInt32Ty),
1777 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1778 std::make_pair(".privates.",
1779 Context.VoidPtrTy.withConst().withRestrict()),
1782 Context.getPointerType(CopyFnType).withConst().withRestrict()),
1783 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1784 std::make_pair(".lb.", KmpUInt64Ty),
1785 std::make_pair(".ub.", KmpUInt64Ty), std::make_pair(".st.", KmpInt64Ty),
1786 std::make_pair(".liter.", KmpInt32Ty),
1787 std::make_pair(StringRef(), QualType()) // __context with shared vars
1789 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1791 // Mark this captured region as inlined, because we don't use outlined
1792 // function directly.
1793 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1794 AlwaysInlineAttr::CreateImplicit(
1795 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1798 case OMPD_distribute_parallel_for_simd:
1799 case OMPD_distribute_simd:
1800 case OMPD_distribute_parallel_for:
1801 case OMPD_teams_distribute:
1802 case OMPD_teams_distribute_simd:
1803 case OMPD_teams_distribute_parallel_for_simd:
1804 case OMPD_teams_distribute_parallel_for:
1805 case OMPD_target_teams_distribute:
1806 case OMPD_target_teams_distribute_parallel_for:
1807 case OMPD_target_teams_distribute_parallel_for_simd:
1808 case OMPD_target_teams_distribute_simd: {
1809 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1810 QualType KmpInt32PtrTy =
1811 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1812 Sema::CapturedParamNameType Params[] = {
1813 std::make_pair(".global_tid.", KmpInt32PtrTy),
1814 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1815 std::make_pair(".previous.lb.", Context.getSizeType()),
1816 std::make_pair(".previous.ub.", Context.getSizeType()),
1817 std::make_pair(StringRef(), QualType()) // __context with shared vars
1819 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
1823 case OMPD_threadprivate:
1824 case OMPD_taskyield:
1827 case OMPD_cancellation_point:
1830 case OMPD_target_enter_data:
1831 case OMPD_target_exit_data:
1832 case OMPD_declare_reduction:
1833 case OMPD_declare_simd:
1834 case OMPD_declare_target:
1835 case OMPD_end_declare_target:
1836 case OMPD_target_update:
1837 llvm_unreachable("OpenMP Directive is not allowed");
1839 llvm_unreachable("Unknown OpenMP directive");
1843 int Sema::getOpenMPCaptureLevels(OpenMPDirectiveKind DKind) {
1844 SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
1845 getOpenMPCaptureRegions(CaptureRegions, DKind);
1846 return CaptureRegions.size();
1849 static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id,
1850 Expr *CaptureExpr, bool WithInit,
1851 bool AsExpression) {
1852 assert(CaptureExpr);
1853 ASTContext &C = S.getASTContext();
1854 Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
1855 QualType Ty = Init->getType();
1856 if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) {
1857 if (S.getLangOpts().CPlusPlus)
1858 Ty = C.getLValueReferenceType(Ty);
1860 Ty = C.getPointerType(Ty);
1862 S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init);
1863 if (!Res.isUsable())
1869 auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty,
1870 CaptureExpr->getLocStart());
1872 CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C, SourceRange()));
1873 S.CurContext->addHiddenDecl(CED);
1874 S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false);
1878 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
1880 OMPCapturedExprDecl *CD;
1881 if (auto *VD = S.IsOpenMPCapturedDecl(D))
1882 CD = cast<OMPCapturedExprDecl>(VD);
1884 CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit,
1885 /*AsExpression=*/false);
1886 return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1887 CaptureExpr->getExprLoc());
1890 static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) {
1893 buildCaptureDecl(S, &S.getASTContext().Idents.get(".capture_expr."),
1894 CaptureExpr, /*WithInit=*/true, /*AsExpression=*/true);
1895 Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1896 CaptureExpr->getExprLoc());
1898 ExprResult Res = Ref;
1899 if (!S.getLangOpts().CPlusPlus &&
1900 CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() &&
1901 Ref->getType()->isPointerType())
1902 Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref);
1903 if (!Res.isUsable())
1905 return CaptureExpr->isGLValue() ? Res : S.DefaultLvalueConversion(Res.get());
1909 // OpenMP directives parsed in this section are represented as a
1910 // CapturedStatement with an associated statement. If a syntax error
1911 // is detected during the parsing of the associated statement, the
1912 // compiler must abort processing and close the CapturedStatement.
1914 // Combined directives such as 'target parallel' have more than one
1915 // nested CapturedStatements. This RAII ensures that we unwind out
1916 // of all the nested CapturedStatements when an error is found.
1917 class CaptureRegionUnwinderRAII {
1921 OpenMPDirectiveKind DKind;
1924 CaptureRegionUnwinderRAII(Sema &S, bool &ErrorFound,
1925 OpenMPDirectiveKind DKind)
1926 : S(S), ErrorFound(ErrorFound), DKind(DKind) {}
1927 ~CaptureRegionUnwinderRAII() {
1929 int ThisCaptureLevel = S.getOpenMPCaptureLevels(DKind);
1930 while (--ThisCaptureLevel >= 0)
1931 S.ActOnCapturedRegionError();
1937 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
1938 ArrayRef<OMPClause *> Clauses) {
1939 bool ErrorFound = false;
1940 CaptureRegionUnwinderRAII CaptureRegionUnwinder(
1941 *this, ErrorFound, DSAStack->getCurrentDirective());
1942 if (!S.isUsable()) {
1947 OMPOrderedClause *OC = nullptr;
1948 OMPScheduleClause *SC = nullptr;
1949 SmallVector<OMPLinearClause *, 4> LCs;
1950 SmallVector<OMPClauseWithPreInit *, 8> PICs;
1951 // This is required for proper codegen.
1952 for (auto *Clause : Clauses) {
1953 if (isOpenMPPrivate(Clause->getClauseKind()) ||
1954 Clause->getClauseKind() == OMPC_copyprivate ||
1955 (getLangOpts().OpenMPUseTLS &&
1956 getASTContext().getTargetInfo().isTLSSupported() &&
1957 Clause->getClauseKind() == OMPC_copyin)) {
1958 DSAStack->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin);
1959 // Mark all variables in private list clauses as used in inner region.
1960 for (auto *VarRef : Clause->children()) {
1961 if (auto *E = cast_or_null<Expr>(VarRef)) {
1962 MarkDeclarationsReferencedInExpr(E);
1965 DSAStack->setForceVarCapturing(/*V=*/false);
1966 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective())) {
1967 if (auto *C = OMPClauseWithPreInit::get(Clause))
1969 if (auto *C = OMPClauseWithPostUpdate::get(Clause)) {
1970 if (auto *E = C->getPostUpdateExpr())
1971 MarkDeclarationsReferencedInExpr(E);
1974 if (Clause->getClauseKind() == OMPC_schedule)
1975 SC = cast<OMPScheduleClause>(Clause);
1976 else if (Clause->getClauseKind() == OMPC_ordered)
1977 OC = cast<OMPOrderedClause>(Clause);
1978 else if (Clause->getClauseKind() == OMPC_linear)
1979 LCs.push_back(cast<OMPLinearClause>(Clause));
1981 // OpenMP, 2.7.1 Loop Construct, Restrictions
1982 // The nonmonotonic modifier cannot be specified if an ordered clause is
1985 (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
1986 SC->getSecondScheduleModifier() ==
1987 OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
1989 Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
1990 ? SC->getFirstScheduleModifierLoc()
1991 : SC->getSecondScheduleModifierLoc(),
1992 diag::err_omp_schedule_nonmonotonic_ordered)
1993 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1996 if (!LCs.empty() && OC && OC->getNumForLoops()) {
1997 for (auto *C : LCs) {
1998 Diag(C->getLocStart(), diag::err_omp_linear_ordered)
1999 << SourceRange(OC->getLocStart(), OC->getLocEnd());
2003 if (isOpenMPWorksharingDirective(DSAStack->getCurrentDirective()) &&
2004 isOpenMPSimdDirective(DSAStack->getCurrentDirective()) && OC &&
2005 OC->getNumForLoops()) {
2006 Diag(OC->getLocStart(), diag::err_omp_ordered_simd)
2007 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
2014 SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
2015 getOpenMPCaptureRegions(CaptureRegions, DSAStack->getCurrentDirective());
2016 for (auto ThisCaptureRegion : llvm::reverse(CaptureRegions)) {
2017 // Mark all variables in private list clauses as used in inner region.
2018 // Required for proper codegen of combined directives.
2019 // TODO: add processing for other clauses.
2020 if (isParallelOrTaskRegion(DSAStack->getCurrentDirective())) {
2021 for (auto *C : PICs) {
2022 OpenMPDirectiveKind CaptureRegion = C->getCaptureRegion();
2023 // Find the particular capture region for the clause if the
2024 // directive is a combined one with multiple capture regions.
2025 // If the directive is not a combined one, the capture region
2026 // associated with the clause is OMPD_unknown and is generated
2028 if (CaptureRegion == ThisCaptureRegion ||
2029 CaptureRegion == OMPD_unknown) {
2030 if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
2031 for (auto *D : DS->decls())
2032 MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
2037 SR = ActOnCapturedRegionEnd(SR.get());
2042 static bool checkCancelRegion(Sema &SemaRef, OpenMPDirectiveKind CurrentRegion,
2043 OpenMPDirectiveKind CancelRegion,
2044 SourceLocation StartLoc) {
2045 // CancelRegion is only needed for cancel and cancellation_point.
2046 if (CurrentRegion != OMPD_cancel && CurrentRegion != OMPD_cancellation_point)
2049 if (CancelRegion == OMPD_parallel || CancelRegion == OMPD_for ||
2050 CancelRegion == OMPD_sections || CancelRegion == OMPD_taskgroup)
2053 SemaRef.Diag(StartLoc, diag::err_omp_wrong_cancel_region)
2054 << getOpenMPDirectiveName(CancelRegion);
2058 static bool checkNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack,
2059 OpenMPDirectiveKind CurrentRegion,
2060 const DeclarationNameInfo &CurrentName,
2061 OpenMPDirectiveKind CancelRegion,
2062 SourceLocation StartLoc) {
2063 if (Stack->getCurScope()) {
2064 auto ParentRegion = Stack->getParentDirective();
2065 auto OffendingRegion = ParentRegion;
2066 bool NestingProhibited = false;
2067 bool CloseNesting = true;
2068 bool OrphanSeen = false;
2071 ShouldBeInParallelRegion,
2072 ShouldBeInOrderedRegion,
2073 ShouldBeInTargetRegion,
2074 ShouldBeInTeamsRegion
2075 } Recommend = NoRecommend;
2076 if (isOpenMPSimdDirective(ParentRegion) && CurrentRegion != OMPD_ordered) {
2077 // OpenMP [2.16, Nesting of Regions]
2078 // OpenMP constructs may not be nested inside a simd region.
2079 // OpenMP [2.8.1,simd Construct, Restrictions]
2080 // An ordered construct with the simd clause is the only OpenMP
2081 // construct that can appear in the simd region.
2082 // Allowing a SIMD construct nested in another SIMD construct is an
2083 // extension. The OpenMP 4.5 spec does not allow it. Issue a warning
2085 SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd)
2086 ? diag::err_omp_prohibited_region_simd
2087 : diag::warn_omp_nesting_simd);
2088 return CurrentRegion != OMPD_simd;
2090 if (ParentRegion == OMPD_atomic) {
2091 // OpenMP [2.16, Nesting of Regions]
2092 // OpenMP constructs may not be nested inside an atomic region.
2093 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic);
2096 if (CurrentRegion == OMPD_section) {
2097 // OpenMP [2.7.2, sections Construct, Restrictions]
2098 // Orphaned section directives are prohibited. That is, the section
2099 // directives must appear within the sections construct and must not be
2100 // encountered elsewhere in the sections region.
2101 if (ParentRegion != OMPD_sections &&
2102 ParentRegion != OMPD_parallel_sections) {
2103 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
2104 << (ParentRegion != OMPD_unknown)
2105 << getOpenMPDirectiveName(ParentRegion);
2110 // Allow some constructs (except teams) to be orphaned (they could be
2111 // used in functions, called from OpenMP regions with the required
2113 if (ParentRegion == OMPD_unknown &&
2114 !isOpenMPNestingTeamsDirective(CurrentRegion))
2116 if (CurrentRegion == OMPD_cancellation_point ||
2117 CurrentRegion == OMPD_cancel) {
2118 // OpenMP [2.16, Nesting of Regions]
2119 // A cancellation point construct for which construct-type-clause is
2120 // taskgroup must be nested inside a task construct. A cancellation
2121 // point construct for which construct-type-clause is not taskgroup must
2122 // be closely nested inside an OpenMP construct that matches the type
2123 // specified in construct-type-clause.
2124 // A cancel construct for which construct-type-clause is taskgroup must be
2125 // nested inside a task construct. A cancel construct for which
2126 // construct-type-clause is not taskgroup must be closely nested inside an
2127 // OpenMP construct that matches the type specified in
2128 // construct-type-clause.
2130 !((CancelRegion == OMPD_parallel &&
2131 (ParentRegion == OMPD_parallel ||
2132 ParentRegion == OMPD_target_parallel)) ||
2133 (CancelRegion == OMPD_for &&
2134 (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for ||
2135 ParentRegion == OMPD_target_parallel_for)) ||
2136 (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) ||
2137 (CancelRegion == OMPD_sections &&
2138 (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
2139 ParentRegion == OMPD_parallel_sections)));
2140 } else if (CurrentRegion == OMPD_master) {
2141 // OpenMP [2.16, Nesting of Regions]
2142 // A master region may not be closely nested inside a worksharing,
2143 // atomic, or explicit task region.
2144 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2145 isOpenMPTaskingDirective(ParentRegion);
2146 } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
2147 // OpenMP [2.16, Nesting of Regions]
2148 // A critical region may not be nested (closely or otherwise) inside a
2149 // critical region with the same name. Note that this restriction is not
2150 // sufficient to prevent deadlock.
2151 SourceLocation PreviousCriticalLoc;
2152 bool DeadLock = Stack->hasDirective(
2153 [CurrentName, &PreviousCriticalLoc](OpenMPDirectiveKind K,
2154 const DeclarationNameInfo &DNI,
2155 SourceLocation Loc) -> bool {
2156 if (K == OMPD_critical && DNI.getName() == CurrentName.getName()) {
2157 PreviousCriticalLoc = Loc;
2162 false /* skip top directive */);
2164 SemaRef.Diag(StartLoc,
2165 diag::err_omp_prohibited_region_critical_same_name)
2166 << CurrentName.getName();
2167 if (PreviousCriticalLoc.isValid())
2168 SemaRef.Diag(PreviousCriticalLoc,
2169 diag::note_omp_previous_critical_region);
2172 } else if (CurrentRegion == OMPD_barrier) {
2173 // OpenMP [2.16, Nesting of Regions]
2174 // A barrier region may not be closely nested inside a worksharing,
2175 // explicit task, critical, ordered, atomic, or master region.
2176 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2177 isOpenMPTaskingDirective(ParentRegion) ||
2178 ParentRegion == OMPD_master ||
2179 ParentRegion == OMPD_critical ||
2180 ParentRegion == OMPD_ordered;
2181 } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
2182 !isOpenMPParallelDirective(CurrentRegion) &&
2183 !isOpenMPTeamsDirective(CurrentRegion)) {
2184 // OpenMP [2.16, Nesting of Regions]
2185 // A worksharing region may not be closely nested inside a worksharing,
2186 // explicit task, critical, ordered, atomic, or master region.
2187 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2188 isOpenMPTaskingDirective(ParentRegion) ||
2189 ParentRegion == OMPD_master ||
2190 ParentRegion == OMPD_critical ||
2191 ParentRegion == OMPD_ordered;
2192 Recommend = ShouldBeInParallelRegion;
2193 } else if (CurrentRegion == OMPD_ordered) {
2194 // OpenMP [2.16, Nesting of Regions]
2195 // An ordered region may not be closely nested inside a critical,
2196 // atomic, or explicit task region.
2197 // An ordered region must be closely nested inside a loop region (or
2198 // parallel loop region) with an ordered clause.
2199 // OpenMP [2.8.1,simd Construct, Restrictions]
2200 // An ordered construct with the simd clause is the only OpenMP construct
2201 // that can appear in the simd region.
2202 NestingProhibited = ParentRegion == OMPD_critical ||
2203 isOpenMPTaskingDirective(ParentRegion) ||
2204 !(isOpenMPSimdDirective(ParentRegion) ||
2205 Stack->isParentOrderedRegion());
2206 Recommend = ShouldBeInOrderedRegion;
2207 } else if (isOpenMPNestingTeamsDirective(CurrentRegion)) {
2208 // OpenMP [2.16, Nesting of Regions]
2209 // If specified, a teams construct must be contained within a target
2211 NestingProhibited = ParentRegion != OMPD_target;
2212 OrphanSeen = ParentRegion == OMPD_unknown;
2213 Recommend = ShouldBeInTargetRegion;
2214 Stack->setParentTeamsRegionLoc(Stack->getConstructLoc());
2216 if (!NestingProhibited &&
2217 !isOpenMPTargetExecutionDirective(CurrentRegion) &&
2218 !isOpenMPTargetDataManagementDirective(CurrentRegion) &&
2219 (ParentRegion == OMPD_teams || ParentRegion == OMPD_target_teams)) {
2220 // OpenMP [2.16, Nesting of Regions]
2221 // distribute, parallel, parallel sections, parallel workshare, and the
2222 // parallel loop and parallel loop SIMD constructs are the only OpenMP
2223 // constructs that can be closely nested in the teams region.
2224 NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) &&
2225 !isOpenMPDistributeDirective(CurrentRegion);
2226 Recommend = ShouldBeInParallelRegion;
2228 if (!NestingProhibited &&
2229 isOpenMPNestingDistributeDirective(CurrentRegion)) {
2230 // OpenMP 4.5 [2.17 Nesting of Regions]
2231 // The region associated with the distribute construct must be strictly
2232 // nested inside a teams region
2234 (ParentRegion != OMPD_teams && ParentRegion != OMPD_target_teams);
2235 Recommend = ShouldBeInTeamsRegion;
2237 if (!NestingProhibited &&
2238 (isOpenMPTargetExecutionDirective(CurrentRegion) ||
2239 isOpenMPTargetDataManagementDirective(CurrentRegion))) {
2240 // OpenMP 4.5 [2.17 Nesting of Regions]
2241 // If a target, target update, target data, target enter data, or
2242 // target exit data construct is encountered during execution of a
2243 // target region, the behavior is unspecified.
2244 NestingProhibited = Stack->hasDirective(
2245 [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &,
2246 SourceLocation) -> bool {
2247 if (isOpenMPTargetExecutionDirective(K)) {
2248 OffendingRegion = K;
2253 false /* don't skip top directive */);
2254 CloseNesting = false;
2256 if (NestingProhibited) {
2258 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_device_directive)
2259 << getOpenMPDirectiveName(CurrentRegion) << Recommend;
2261 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region)
2262 << CloseNesting << getOpenMPDirectiveName(OffendingRegion)
2263 << Recommend << getOpenMPDirectiveName(CurrentRegion);
2271 static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
2272 ArrayRef<OMPClause *> Clauses,
2273 ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
2274 bool ErrorFound = false;
2275 unsigned NamedModifiersNumber = 0;
2276 SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers(
2278 SmallVector<SourceLocation, 4> NameModifierLoc;
2279 for (const auto *C : Clauses) {
2280 if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {
2281 // At most one if clause without a directive-name-modifier can appear on
2283 OpenMPDirectiveKind CurNM = IC->getNameModifier();
2284 if (FoundNameModifiers[CurNM]) {
2285 S.Diag(C->getLocStart(), diag::err_omp_more_one_clause)
2286 << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if)
2287 << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM);
2289 } else if (CurNM != OMPD_unknown) {
2290 NameModifierLoc.push_back(IC->getNameModifierLoc());
2291 ++NamedModifiersNumber;
2293 FoundNameModifiers[CurNM] = IC;
2294 if (CurNM == OMPD_unknown)
2296 // Check if the specified name modifier is allowed for the current
2298 // At most one if clause with the particular directive-name-modifier can
2299 // appear on the directive.
2300 bool MatchFound = false;
2301 for (auto NM : AllowedNameModifiers) {
2308 S.Diag(IC->getNameModifierLoc(),
2309 diag::err_omp_wrong_if_directive_name_modifier)
2310 << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind);
2315 // If any if clause on the directive includes a directive-name-modifier then
2316 // all if clauses on the directive must include a directive-name-modifier.
2317 if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {
2318 if (NamedModifiersNumber == AllowedNameModifiers.size()) {
2319 S.Diag(FoundNameModifiers[OMPD_unknown]->getLocStart(),
2320 diag::err_omp_no_more_if_clause);
2323 std::string Sep(", ");
2324 unsigned AllowedCnt = 0;
2325 unsigned TotalAllowedNum =
2326 AllowedNameModifiers.size() - NamedModifiersNumber;
2327 for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End;
2329 OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt];
2330 if (!FoundNameModifiers[NM]) {
2332 Values += getOpenMPDirectiveName(NM);
2334 if (AllowedCnt + 2 == TotalAllowedNum)
2336 else if (AllowedCnt + 1 != TotalAllowedNum)
2341 S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getLocStart(),
2342 diag::err_omp_unnamed_if_clause)
2343 << (TotalAllowedNum > 1) << Values;
2345 for (auto Loc : NameModifierLoc) {
2346 S.Diag(Loc, diag::note_omp_previous_named_if_clause);
2353 StmtResult Sema::ActOnOpenMPExecutableDirective(
2354 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
2355 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
2356 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
2357 StmtResult Res = StmtError();
2358 // First check CancelRegion which is then used in checkNestingOfRegions.
2359 if (checkCancelRegion(*this, Kind, CancelRegion, StartLoc) ||
2360 checkNestingOfRegions(*this, DSAStack, Kind, DirName, CancelRegion,
2364 llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
2365 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
2366 bool ErrorFound = false;
2367 ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
2369 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
2371 // Check default data sharing attributes for referenced variables.
2372 DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt));
2373 int ThisCaptureLevel = getOpenMPCaptureLevels(Kind);
2375 while (--ThisCaptureLevel >= 0)
2376 S = cast<CapturedStmt>(S)->getCapturedStmt();
2377 DSAChecker.Visit(S);
2378 if (DSAChecker.isErrorFound())
2380 // Generate list of implicitly defined firstprivate variables.
2381 VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA();
2383 if (!DSAChecker.getImplicitFirstprivate().empty()) {
2384 if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause(
2385 DSAChecker.getImplicitFirstprivate(), SourceLocation(),
2386 SourceLocation(), SourceLocation())) {
2387 ClausesWithImplicit.push_back(Implicit);
2388 ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() !=
2389 DSAChecker.getImplicitFirstprivate().size();
2395 llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
2398 Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
2400 AllowedNameModifiers.push_back(OMPD_parallel);
2403 Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
2404 VarsWithInheritedDSA);
2407 Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
2408 VarsWithInheritedDSA);
2411 Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2412 EndLoc, VarsWithInheritedDSA);
2415 Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
2419 assert(ClausesWithImplicit.empty() &&
2420 "No clauses are allowed for 'omp section' directive");
2421 Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
2424 Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
2428 assert(ClausesWithImplicit.empty() &&
2429 "No clauses are allowed for 'omp master' directive");
2430 Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
2433 Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt,
2436 case OMPD_parallel_for:
2437 Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc,
2438 EndLoc, VarsWithInheritedDSA);
2439 AllowedNameModifiers.push_back(OMPD_parallel);
2441 case OMPD_parallel_for_simd:
2442 Res = ActOnOpenMPParallelForSimdDirective(
2443 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2444 AllowedNameModifiers.push_back(OMPD_parallel);
2446 case OMPD_parallel_sections:
2447 Res = ActOnOpenMPParallelSectionsDirective(ClausesWithImplicit, AStmt,
2449 AllowedNameModifiers.push_back(OMPD_parallel);
2453 ActOnOpenMPTaskDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
2454 AllowedNameModifiers.push_back(OMPD_task);
2456 case OMPD_taskyield:
2457 assert(ClausesWithImplicit.empty() &&
2458 "No clauses are allowed for 'omp taskyield' directive");
2459 assert(AStmt == nullptr &&
2460 "No associated statement allowed for 'omp taskyield' directive");
2461 Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc);
2464 assert(ClausesWithImplicit.empty() &&
2465 "No clauses are allowed for 'omp barrier' directive");
2466 assert(AStmt == nullptr &&
2467 "No associated statement allowed for 'omp barrier' directive");
2468 Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
2471 assert(ClausesWithImplicit.empty() &&
2472 "No clauses are allowed for 'omp taskwait' directive");
2473 assert(AStmt == nullptr &&
2474 "No associated statement allowed for 'omp taskwait' directive");
2475 Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc);
2477 case OMPD_taskgroup:
2478 assert(ClausesWithImplicit.empty() &&
2479 "No clauses are allowed for 'omp taskgroup' directive");
2480 Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc);
2483 assert(AStmt == nullptr &&
2484 "No associated statement allowed for 'omp flush' directive");
2485 Res = ActOnOpenMPFlushDirective(ClausesWithImplicit, StartLoc, EndLoc);
2488 Res = ActOnOpenMPOrderedDirective(ClausesWithImplicit, AStmt, StartLoc,
2492 Res = ActOnOpenMPAtomicDirective(ClausesWithImplicit, AStmt, StartLoc,
2497 ActOnOpenMPTeamsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
2500 Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc,
2502 AllowedNameModifiers.push_back(OMPD_target);
2504 case OMPD_target_parallel:
2505 Res = ActOnOpenMPTargetParallelDirective(ClausesWithImplicit, AStmt,
2507 AllowedNameModifiers.push_back(OMPD_target);
2508 AllowedNameModifiers.push_back(OMPD_parallel);
2510 case OMPD_target_parallel_for:
2511 Res = ActOnOpenMPTargetParallelForDirective(
2512 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2513 AllowedNameModifiers.push_back(OMPD_target);
2514 AllowedNameModifiers.push_back(OMPD_parallel);
2516 case OMPD_cancellation_point:
2517 assert(ClausesWithImplicit.empty() &&
2518 "No clauses are allowed for 'omp cancellation point' directive");
2519 assert(AStmt == nullptr && "No associated statement allowed for 'omp "
2520 "cancellation point' directive");
2521 Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion);
2524 assert(AStmt == nullptr &&
2525 "No associated statement allowed for 'omp cancel' directive");
2526 Res = ActOnOpenMPCancelDirective(ClausesWithImplicit, StartLoc, EndLoc,
2528 AllowedNameModifiers.push_back(OMPD_cancel);
2530 case OMPD_target_data:
2531 Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc,
2533 AllowedNameModifiers.push_back(OMPD_target_data);
2535 case OMPD_target_enter_data:
2536 Res = ActOnOpenMPTargetEnterDataDirective(ClausesWithImplicit, StartLoc,
2538 AllowedNameModifiers.push_back(OMPD_target_enter_data);
2540 case OMPD_target_exit_data:
2541 Res = ActOnOpenMPTargetExitDataDirective(ClausesWithImplicit, StartLoc,
2543 AllowedNameModifiers.push_back(OMPD_target_exit_data);
2546 Res = ActOnOpenMPTaskLoopDirective(ClausesWithImplicit, AStmt, StartLoc,
2547 EndLoc, VarsWithInheritedDSA);
2548 AllowedNameModifiers.push_back(OMPD_taskloop);
2550 case OMPD_taskloop_simd:
2551 Res = ActOnOpenMPTaskLoopSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2552 EndLoc, VarsWithInheritedDSA);
2553 AllowedNameModifiers.push_back(OMPD_taskloop);
2555 case OMPD_distribute:
2556 Res = ActOnOpenMPDistributeDirective(ClausesWithImplicit, AStmt, StartLoc,
2557 EndLoc, VarsWithInheritedDSA);
2559 case OMPD_target_update:
2560 assert(!AStmt && "Statement is not allowed for target update");
2562 ActOnOpenMPTargetUpdateDirective(ClausesWithImplicit, StartLoc, EndLoc);
2563 AllowedNameModifiers.push_back(OMPD_target_update);
2565 case OMPD_distribute_parallel_for:
2566 Res = ActOnOpenMPDistributeParallelForDirective(
2567 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2568 AllowedNameModifiers.push_back(OMPD_parallel);
2570 case OMPD_distribute_parallel_for_simd:
2571 Res = ActOnOpenMPDistributeParallelForSimdDirective(
2572 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2573 AllowedNameModifiers.push_back(OMPD_parallel);
2575 case OMPD_distribute_simd:
2576 Res = ActOnOpenMPDistributeSimdDirective(
2577 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2579 case OMPD_target_parallel_for_simd:
2580 Res = ActOnOpenMPTargetParallelForSimdDirective(
2581 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2582 AllowedNameModifiers.push_back(OMPD_target);
2583 AllowedNameModifiers.push_back(OMPD_parallel);
2585 case OMPD_target_simd:
2586 Res = ActOnOpenMPTargetSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2587 EndLoc, VarsWithInheritedDSA);
2588 AllowedNameModifiers.push_back(OMPD_target);
2590 case OMPD_teams_distribute:
2591 Res = ActOnOpenMPTeamsDistributeDirective(
2592 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2594 case OMPD_teams_distribute_simd:
2595 Res = ActOnOpenMPTeamsDistributeSimdDirective(
2596 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2598 case OMPD_teams_distribute_parallel_for_simd:
2599 Res = ActOnOpenMPTeamsDistributeParallelForSimdDirective(
2600 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2601 AllowedNameModifiers.push_back(OMPD_parallel);
2603 case OMPD_teams_distribute_parallel_for:
2604 Res = ActOnOpenMPTeamsDistributeParallelForDirective(
2605 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2606 AllowedNameModifiers.push_back(OMPD_parallel);
2608 case OMPD_target_teams:
2609 Res = ActOnOpenMPTargetTeamsDirective(ClausesWithImplicit, AStmt, StartLoc,
2611 AllowedNameModifiers.push_back(OMPD_target);
2613 case OMPD_target_teams_distribute:
2614 Res = ActOnOpenMPTargetTeamsDistributeDirective(
2615 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2616 AllowedNameModifiers.push_back(OMPD_target);
2618 case OMPD_target_teams_distribute_parallel_for:
2619 Res = ActOnOpenMPTargetTeamsDistributeParallelForDirective(
2620 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2621 AllowedNameModifiers.push_back(OMPD_target);
2622 AllowedNameModifiers.push_back(OMPD_parallel);
2624 case OMPD_target_teams_distribute_parallel_for_simd:
2625 Res = ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
2626 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2627 AllowedNameModifiers.push_back(OMPD_target);
2628 AllowedNameModifiers.push_back(OMPD_parallel);
2630 case OMPD_target_teams_distribute_simd:
2631 Res = ActOnOpenMPTargetTeamsDistributeSimdDirective(
2632 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2633 AllowedNameModifiers.push_back(OMPD_target);
2635 case OMPD_declare_target:
2636 case OMPD_end_declare_target:
2637 case OMPD_threadprivate:
2638 case OMPD_declare_reduction:
2639 case OMPD_declare_simd:
2640 llvm_unreachable("OpenMP Directive is not allowed");
2642 llvm_unreachable("Unknown OpenMP directive");
2645 for (auto P : VarsWithInheritedDSA) {
2646 Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
2647 << P.first << P.second->getSourceRange();
2649 ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound;
2651 if (!AllowedNameModifiers.empty())
2652 ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) ||
2660 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
2661 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
2662 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
2663 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
2664 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
2665 assert(Aligneds.size() == Alignments.size());
2666 assert(Linears.size() == LinModifiers.size());
2667 assert(Linears.size() == Steps.size());
2668 if (!DG || DG.get().isNull())
2669 return DeclGroupPtrTy();
2671 if (!DG.get().isSingleDecl()) {
2672 Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd);
2675 auto *ADecl = DG.get().getSingleDecl();
2676 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
2677 ADecl = FTD->getTemplatedDecl();
2679 auto *FD = dyn_cast<FunctionDecl>(ADecl);
2681 Diag(ADecl->getLocation(), diag::err_omp_function_expected);
2682 return DeclGroupPtrTy();
2685 // OpenMP [2.8.2, declare simd construct, Description]
2686 // The parameter of the simdlen clause must be a constant positive integer
2690 SL = VerifyPositiveIntegerConstantInClause(Simdlen, OMPC_simdlen);
2691 // OpenMP [2.8.2, declare simd construct, Description]
2692 // The special this pointer can be used as if was one of the arguments to the
2693 // function in any of the linear, aligned, or uniform clauses.
2694 // The uniform clause declares one or more arguments to have an invariant
2695 // value for all concurrent invocations of the function in the execution of a
2696 // single SIMD loop.
2697 llvm::DenseMap<Decl *, Expr *> UniformedArgs;
2698 Expr *UniformedLinearThis = nullptr;
2699 for (auto *E : Uniforms) {
2700 E = E->IgnoreParenImpCasts();
2701 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2702 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
2703 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2704 FD->getParamDecl(PVD->getFunctionScopeIndex())
2705 ->getCanonicalDecl() == PVD->getCanonicalDecl()) {
2706 UniformedArgs.insert(std::make_pair(PVD->getCanonicalDecl(), E));
2709 if (isa<CXXThisExpr>(E)) {
2710 UniformedLinearThis = E;
2713 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2714 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2716 // OpenMP [2.8.2, declare simd construct, Description]
2717 // The aligned clause declares that the object to which each list item points
2718 // is aligned to the number of bytes expressed in the optional parameter of
2719 // the aligned clause.
2720 // The special this pointer can be used as if was one of the arguments to the
2721 // function in any of the linear, aligned, or uniform clauses.
2722 // The type of list items appearing in the aligned clause must be array,
2723 // pointer, reference to array, or reference to pointer.
2724 llvm::DenseMap<Decl *, Expr *> AlignedArgs;
2725 Expr *AlignedThis = nullptr;
2726 for (auto *E : Aligneds) {
2727 E = E->IgnoreParenImpCasts();
2728 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2729 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2730 auto *CanonPVD = PVD->getCanonicalDecl();
2731 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2732 FD->getParamDecl(PVD->getFunctionScopeIndex())
2733 ->getCanonicalDecl() == CanonPVD) {
2734 // OpenMP [2.8.1, simd construct, Restrictions]
2735 // A list-item cannot appear in more than one aligned clause.
2736 if (AlignedArgs.count(CanonPVD) > 0) {
2737 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
2738 << 1 << E->getSourceRange();
2739 Diag(AlignedArgs[CanonPVD]->getExprLoc(),
2740 diag::note_omp_explicit_dsa)
2741 << getOpenMPClauseName(OMPC_aligned);
2744 AlignedArgs[CanonPVD] = E;
2745 QualType QTy = PVD->getType()
2746 .getNonReferenceType()
2747 .getUnqualifiedType()
2748 .getCanonicalType();
2749 const Type *Ty = QTy.getTypePtrOrNull();
2750 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
2751 Diag(E->getExprLoc(), diag::err_omp_aligned_expected_array_or_ptr)
2752 << QTy << getLangOpts().CPlusPlus << E->getSourceRange();
2753 Diag(PVD->getLocation(), diag::note_previous_decl) << PVD;
2758 if (isa<CXXThisExpr>(E)) {
2760 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
2761 << 2 << E->getSourceRange();
2762 Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa)
2763 << getOpenMPClauseName(OMPC_aligned);
2768 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2769 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2771 // The optional parameter of the aligned clause, alignment, must be a constant
2772 // positive integer expression. If no optional parameter is specified,
2773 // implementation-defined default alignments for SIMD instructions on the
2774 // target platforms are assumed.
2775 SmallVector<Expr *, 4> NewAligns;
2776 for (auto *E : Alignments) {
2779 Align = VerifyPositiveIntegerConstantInClause(E, OMPC_aligned);
2780 NewAligns.push_back(Align.get());
2782 // OpenMP [2.8.2, declare simd construct, Description]
2783 // The linear clause declares one or more list items to be private to a SIMD
2784 // lane and to have a linear relationship with respect to the iteration space
2786 // The special this pointer can be used as if was one of the arguments to the
2787 // function in any of the linear, aligned, or uniform clauses.
2788 // When a linear-step expression is specified in a linear clause it must be
2789 // either a constant integer expression or an integer-typed parameter that is
2790 // specified in a uniform clause on the directive.
2791 llvm::DenseMap<Decl *, Expr *> LinearArgs;
2792 const bool IsUniformedThis = UniformedLinearThis != nullptr;
2793 auto MI = LinModifiers.begin();
2794 for (auto *E : Linears) {
2795 auto LinKind = static_cast<OpenMPLinearClauseKind>(*MI);
2797 E = E->IgnoreParenImpCasts();
2798 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2799 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2800 auto *CanonPVD = PVD->getCanonicalDecl();
2801 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2802 FD->getParamDecl(PVD->getFunctionScopeIndex())
2803 ->getCanonicalDecl() == CanonPVD) {
2804 // OpenMP [2.15.3.7, linear Clause, Restrictions]
2805 // A list-item cannot appear in more than one linear clause.
2806 if (LinearArgs.count(CanonPVD) > 0) {
2807 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2808 << getOpenMPClauseName(OMPC_linear)
2809 << getOpenMPClauseName(OMPC_linear) << E->getSourceRange();
2810 Diag(LinearArgs[CanonPVD]->getExprLoc(),
2811 diag::note_omp_explicit_dsa)
2812 << getOpenMPClauseName(OMPC_linear);
2815 // Each argument can appear in at most one uniform or linear clause.
2816 if (UniformedArgs.count(CanonPVD) > 0) {
2817 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2818 << getOpenMPClauseName(OMPC_linear)
2819 << getOpenMPClauseName(OMPC_uniform) << E->getSourceRange();
2820 Diag(UniformedArgs[CanonPVD]->getExprLoc(),
2821 diag::note_omp_explicit_dsa)
2822 << getOpenMPClauseName(OMPC_uniform);
2825 LinearArgs[CanonPVD] = E;
2826 if (E->isValueDependent() || E->isTypeDependent() ||
2827 E->isInstantiationDependent() ||
2828 E->containsUnexpandedParameterPack())
2830 (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind,
2831 PVD->getOriginalType());
2835 if (isa<CXXThisExpr>(E)) {
2836 if (UniformedLinearThis) {
2837 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2838 << getOpenMPClauseName(OMPC_linear)
2839 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear)
2840 << E->getSourceRange();
2841 Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa)
2842 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform
2846 UniformedLinearThis = E;
2847 if (E->isValueDependent() || E->isTypeDependent() ||
2848 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
2850 (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind,
2854 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2855 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2857 Expr *Step = nullptr;
2858 Expr *NewStep = nullptr;
2859 SmallVector<Expr *, 4> NewSteps;
2860 for (auto *E : Steps) {
2861 // Skip the same step expression, it was checked already.
2862 if (Step == E || !E) {
2863 NewSteps.push_back(E ? NewStep : nullptr);
2867 if (auto *DRE = dyn_cast<DeclRefExpr>(Step))
2868 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2869 auto *CanonPVD = PVD->getCanonicalDecl();
2870 if (UniformedArgs.count(CanonPVD) == 0) {
2871 Diag(Step->getExprLoc(), diag::err_omp_expected_uniform_param)
2872 << Step->getSourceRange();
2873 } else if (E->isValueDependent() || E->isTypeDependent() ||
2874 E->isInstantiationDependent() ||
2875 E->containsUnexpandedParameterPack() ||
2876 CanonPVD->getType()->hasIntegerRepresentation())
2877 NewSteps.push_back(Step);
2879 Diag(Step->getExprLoc(), diag::err_omp_expected_int_param)
2880 << Step->getSourceRange();
2885 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
2886 !Step->isInstantiationDependent() &&
2887 !Step->containsUnexpandedParameterPack()) {
2888 NewStep = PerformOpenMPImplicitIntegerConversion(Step->getExprLoc(), Step)
2891 NewStep = VerifyIntegerConstantExpression(NewStep).get();
2893 NewSteps.push_back(NewStep);
2895 auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
2896 Context, BS, SL.get(), const_cast<Expr **>(Uniforms.data()),
2897 Uniforms.size(), const_cast<Expr **>(Aligneds.data()), Aligneds.size(),
2898 const_cast<Expr **>(NewAligns.data()), NewAligns.size(),
2899 const_cast<Expr **>(Linears.data()), Linears.size(),
2900 const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(),
2901 NewSteps.data(), NewSteps.size(), SR);
2902 ADecl->addAttr(NewAttr);
2903 return ConvertDeclToDeclGroup(ADecl);
2906 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
2908 SourceLocation StartLoc,
2909 SourceLocation EndLoc) {
2913 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
2914 // 1.2.2 OpenMP Language Terminology
2915 // Structured block - An executable statement with a single entry at the
2916 // top and a single exit at the bottom.
2917 // The point of exit cannot be a branch out of the structured block.
2918 // longjmp() and throw() must not violate the entry/exit criteria.
2919 CS->getCapturedDecl()->setNothrow();
2921 getCurFunction()->setHasBranchProtectedScope();
2923 return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
2924 DSAStack->isCancelRegion());
2928 /// \brief Helper class for checking canonical form of the OpenMP loops and
2929 /// extracting iteration space of each loop in the loop nest, that will be used
2930 /// for IR generation.
2931 class OpenMPIterationSpaceChecker {
2932 /// \brief Reference to Sema.
2934 /// \brief A location for diagnostics (when there is no some better location).
2935 SourceLocation DefaultLoc;
2936 /// \brief A location for diagnostics (when increment is not compatible).
2937 SourceLocation ConditionLoc;
2938 /// \brief A source location for referring to loop init later.
2939 SourceRange InitSrcRange;
2940 /// \brief A source location for referring to condition later.
2941 SourceRange ConditionSrcRange;
2942 /// \brief A source location for referring to increment later.
2943 SourceRange IncrementSrcRange;
2944 /// \brief Loop variable.
2945 ValueDecl *LCDecl = nullptr;
2946 /// \brief Reference to loop variable.
2947 Expr *LCRef = nullptr;
2948 /// \brief Lower bound (initializer for the var).
2950 /// \brief Upper bound.
2952 /// \brief Loop step (increment).
2953 Expr *Step = nullptr;
2954 /// \brief This flag is true when condition is one of:
2959 bool TestIsLessOp = false;
2960 /// \brief This flag is true when condition is strict ( < or > ).
2961 bool TestIsStrictOp = false;
2962 /// \brief This flag is true when step is subtracted on each iteration.
2963 bool SubtractStep = false;
2966 OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc)
2967 : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {}
2968 /// \brief Check init-expr for canonical loop form and save loop counter
2969 /// variable - #Var and its initialization value - #LB.
2970 bool CheckInit(Stmt *S, bool EmitDiags = true);
2971 /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags
2972 /// for less/greater and for strict/non-strict comparison.
2973 bool CheckCond(Expr *S);
2974 /// \brief Check incr-expr for canonical loop form and return true if it
2975 /// does not conform, otherwise save loop step (#Step).
2976 bool CheckInc(Expr *S);
2977 /// \brief Return the loop counter variable.
2978 ValueDecl *GetLoopDecl() const { return LCDecl; }
2979 /// \brief Return the reference expression to loop counter variable.
2980 Expr *GetLoopDeclRefExpr() const { return LCRef; }
2981 /// \brief Source range of the loop init.
2982 SourceRange GetInitSrcRange() const { return InitSrcRange; }
2983 /// \brief Source range of the loop condition.
2984 SourceRange GetConditionSrcRange() const { return ConditionSrcRange; }
2985 /// \brief Source range of the loop increment.
2986 SourceRange GetIncrementSrcRange() const { return IncrementSrcRange; }
2987 /// \brief True if the step should be subtracted.
2988 bool ShouldSubtractStep() const { return SubtractStep; }
2989 /// \brief Build the expression to calculate the number of iterations.
2991 BuildNumIterations(Scope *S, const bool LimitedType,
2992 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
2993 /// \brief Build the precondition expression for the loops.
2994 Expr *BuildPreCond(Scope *S, Expr *Cond,
2995 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
2996 /// \brief Build reference expression to the counter be used for codegen.
2997 DeclRefExpr *BuildCounterVar(llvm::MapVector<Expr *, DeclRefExpr *> &Captures,
2998 DSAStackTy &DSA) const;
2999 /// \brief Build reference expression to the private counter be used for
3001 Expr *BuildPrivateCounterVar() const;
3002 /// \brief Build initialization of the counter be used for codegen.
3003 Expr *BuildCounterInit() const;
3004 /// \brief Build step of the counter be used for codegen.
3005 Expr *BuildCounterStep() const;
3006 /// \brief Return true if any expression is dependent.
3007 bool Dependent() const;
3010 /// \brief Check the right-hand side of an assignment in the increment
3012 bool CheckIncRHS(Expr *RHS);
3013 /// \brief Helper to set loop counter variable and its initializer.
3014 bool SetLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB);
3015 /// \brief Helper to set upper bound.
3016 bool SetUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR,
3018 /// \brief Helper to set loop increment.
3019 bool SetStep(Expr *NewStep, bool Subtract);
3022 bool OpenMPIterationSpaceChecker::Dependent() const {
3024 assert(!LB && !UB && !Step);
3027 return LCDecl->getType()->isDependentType() ||
3028 (LB && LB->isValueDependent()) || (UB && UB->isValueDependent()) ||
3029 (Step && Step->isValueDependent());
3032 static Expr *getExprAsWritten(Expr *E) {
3033 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(E))
3034 E = ExprTemp->getSubExpr();
3036 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
3037 E = MTE->GetTemporaryExpr();
3039 while (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
3040 E = Binder->getSubExpr();
3042 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
3043 E = ICE->getSubExprAsWritten();
3044 return E->IgnoreParens();
3047 bool OpenMPIterationSpaceChecker::SetLCDeclAndLB(ValueDecl *NewLCDecl,
3050 // State consistency checking to ensure correct usage.
3051 assert(LCDecl == nullptr && LB == nullptr && LCRef == nullptr &&
3052 UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
3053 if (!NewLCDecl || !NewLB)
3055 LCDecl = getCanonicalDecl(NewLCDecl);
3056 LCRef = NewLCRefExpr;
3057 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(NewLB))
3058 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
3059 if ((Ctor->isCopyOrMoveConstructor() ||
3060 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
3061 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
3062 NewLB = CE->getArg(0)->IgnoreParenImpCasts();
3067 bool OpenMPIterationSpaceChecker::SetUB(Expr *NewUB, bool LessOp, bool StrictOp,
3068 SourceRange SR, SourceLocation SL) {
3069 // State consistency checking to ensure correct usage.
3070 assert(LCDecl != nullptr && LB != nullptr && UB == nullptr &&
3071 Step == nullptr && !TestIsLessOp && !TestIsStrictOp);
3075 TestIsLessOp = LessOp;
3076 TestIsStrictOp = StrictOp;
3077 ConditionSrcRange = SR;
3082 bool OpenMPIterationSpaceChecker::SetStep(Expr *NewStep, bool Subtract) {
3083 // State consistency checking to ensure correct usage.
3084 assert(LCDecl != nullptr && LB != nullptr && Step == nullptr);
3087 if (!NewStep->isValueDependent()) {
3088 // Check that the step is integer expression.
3089 SourceLocation StepLoc = NewStep->getLocStart();
3091 SemaRef.PerformOpenMPImplicitIntegerConversion(StepLoc, NewStep);
3092 if (Val.isInvalid())
3094 NewStep = Val.get();
3096 // OpenMP [2.6, Canonical Loop Form, Restrictions]
3097 // If test-expr is of form var relational-op b and relational-op is < or
3098 // <= then incr-expr must cause var to increase on each iteration of the
3099 // loop. If test-expr is of form var relational-op b and relational-op is
3100 // > or >= then incr-expr must cause var to decrease on each iteration of
3102 // If test-expr is of form b relational-op var and relational-op is < or
3103 // <= then incr-expr must cause var to decrease on each iteration of the
3104 // loop. If test-expr is of form b relational-op var and relational-op is
3105 // > or >= then incr-expr must cause var to increase on each iteration of
3107 llvm::APSInt Result;
3108 bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context);
3109 bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation();
3111 IsConstant && Result.isSigned() && (Subtract != Result.isNegative());
3113 IsConstant && Result.isSigned() && (Subtract == Result.isNegative());
3114 bool IsConstZero = IsConstant && !Result.getBoolValue();
3115 if (UB && (IsConstZero ||
3116 (TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract))
3117 : (IsConstPos || (IsUnsigned && !Subtract))))) {
3118 SemaRef.Diag(NewStep->getExprLoc(),
3119 diag::err_omp_loop_incr_not_compatible)
3120 << LCDecl << TestIsLessOp << NewStep->getSourceRange();
3121 SemaRef.Diag(ConditionLoc,
3122 diag::note_omp_loop_cond_requres_compatible_incr)
3123 << TestIsLessOp << ConditionSrcRange;
3126 if (TestIsLessOp == Subtract) {
3128 SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus, NewStep)
3130 Subtract = !Subtract;
3135 SubtractStep = Subtract;
3139 bool OpenMPIterationSpaceChecker::CheckInit(Stmt *S, bool EmitDiags) {
3140 // Check init-expr for canonical loop form and save loop counter
3141 // variable - #Var and its initialization value - #LB.
3142 // OpenMP [2.6] Canonical loop form. init-expr may be one of the following:
3144 // integer-type var = lb
3145 // random-access-iterator-type var = lb
3146 // pointer-type var = lb
3150 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_init);
3154 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
3155 if (!ExprTemp->cleanupsHaveSideEffects())
3156 S = ExprTemp->getSubExpr();
3158 InitSrcRange = S->getSourceRange();
3159 if (Expr *E = dyn_cast<Expr>(S))
3160 S = E->IgnoreParens();
3161 if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3162 if (BO->getOpcode() == BO_Assign) {
3163 auto *LHS = BO->getLHS()->IgnoreParens();
3164 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
3165 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
3166 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3167 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3168 return SetLCDeclAndLB(DRE->getDecl(), DRE, BO->getRHS());
3170 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
3171 if (ME->isArrow() &&
3172 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3173 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3176 } else if (auto *DS = dyn_cast<DeclStmt>(S)) {
3177 if (DS->isSingleDecl()) {
3178 if (auto *Var = dyn_cast_or_null<VarDecl>(DS->getSingleDecl())) {
3179 if (Var->hasInit() && !Var->getType()->isReferenceType()) {
3180 // Accept non-canonical init form here but emit ext. warning.
3181 if (Var->getInitStyle() != VarDecl::CInit && EmitDiags)
3182 SemaRef.Diag(S->getLocStart(),
3183 diag::ext_omp_loop_not_canonical_init)
3184 << S->getSourceRange();
3185 return SetLCDeclAndLB(Var, nullptr, Var->getInit());
3189 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3190 if (CE->getOperator() == OO_Equal) {
3191 auto *LHS = CE->getArg(0);
3192 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
3193 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
3194 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3195 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3196 return SetLCDeclAndLB(DRE->getDecl(), DRE, CE->getArg(1));
3198 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
3199 if (ME->isArrow() &&
3200 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3201 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3206 if (Dependent() || SemaRef.CurContext->isDependentContext())
3209 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_init)
3210 << S->getSourceRange();
3215 /// \brief Ignore parenthesizes, implicit casts, copy constructor and return the
3216 /// variable (which may be the loop variable) if possible.
3217 static const ValueDecl *GetInitLCDecl(Expr *E) {
3220 E = getExprAsWritten(E);
3221 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(E))
3222 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
3223 if ((Ctor->isCopyOrMoveConstructor() ||
3224 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
3225 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
3226 E = CE->getArg(0)->IgnoreParenImpCasts();
3227 if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
3228 if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
3229 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
3230 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3231 return getCanonicalDecl(ME->getMemberDecl());
3232 return getCanonicalDecl(VD);
3235 if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
3236 if (ME->isArrow() && isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3237 return getCanonicalDecl(ME->getMemberDecl());
3241 bool OpenMPIterationSpaceChecker::CheckCond(Expr *S) {
3242 // Check test-expr for canonical form, save upper-bound UB, flags for
3243 // less/greater and for strict/non-strict comparison.
3244 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
3245 // var relational-op b
3246 // b relational-op var
3249 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_cond) << LCDecl;
3252 S = getExprAsWritten(S);
3253 SourceLocation CondLoc = S->getLocStart();
3254 if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3255 if (BO->isRelationalOp()) {
3256 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3257 return SetUB(BO->getRHS(),
3258 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_LE),
3259 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
3260 BO->getSourceRange(), BO->getOperatorLoc());
3261 if (GetInitLCDecl(BO->getRHS()) == LCDecl)
3262 return SetUB(BO->getLHS(),
3263 (BO->getOpcode() == BO_GT || BO->getOpcode() == BO_GE),
3264 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
3265 BO->getSourceRange(), BO->getOperatorLoc());
3267 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3268 if (CE->getNumArgs() == 2) {
3269 auto Op = CE->getOperator();
3272 case OO_GreaterEqual:
3275 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3276 return SetUB(CE->getArg(1), Op == OO_Less || Op == OO_LessEqual,
3277 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
3278 CE->getOperatorLoc());
3279 if (GetInitLCDecl(CE->getArg(1)) == LCDecl)
3280 return SetUB(CE->getArg(0), Op == OO_Greater || Op == OO_GreaterEqual,
3281 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
3282 CE->getOperatorLoc());
3289 if (Dependent() || SemaRef.CurContext->isDependentContext())
3291 SemaRef.Diag(CondLoc, diag::err_omp_loop_not_canonical_cond)
3292 << S->getSourceRange() << LCDecl;
3296 bool OpenMPIterationSpaceChecker::CheckIncRHS(Expr *RHS) {
3297 // RHS of canonical loop form increment can be:
3302 RHS = RHS->IgnoreParenImpCasts();
3303 if (auto *BO = dyn_cast<BinaryOperator>(RHS)) {
3304 if (BO->isAdditiveOp()) {
3305 bool IsAdd = BO->getOpcode() == BO_Add;
3306 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3307 return SetStep(BO->getRHS(), !IsAdd);
3308 if (IsAdd && GetInitLCDecl(BO->getRHS()) == LCDecl)
3309 return SetStep(BO->getLHS(), false);
3311 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(RHS)) {
3312 bool IsAdd = CE->getOperator() == OO_Plus;
3313 if ((IsAdd || CE->getOperator() == OO_Minus) && CE->getNumArgs() == 2) {
3314 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3315 return SetStep(CE->getArg(1), !IsAdd);
3316 if (IsAdd && GetInitLCDecl(CE->getArg(1)) == LCDecl)
3317 return SetStep(CE->getArg(0), false);
3320 if (Dependent() || SemaRef.CurContext->isDependentContext())
3322 SemaRef.Diag(RHS->getLocStart(), diag::err_omp_loop_not_canonical_incr)
3323 << RHS->getSourceRange() << LCDecl;
3327 bool OpenMPIterationSpaceChecker::CheckInc(Expr *S) {
3328 // Check incr-expr for canonical loop form and return true if it
3329 // does not conform.
3330 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
3342 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_incr) << LCDecl;
3345 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
3346 if (!ExprTemp->cleanupsHaveSideEffects())
3347 S = ExprTemp->getSubExpr();
3349 IncrementSrcRange = S->getSourceRange();
3350 S = S->IgnoreParens();
3351 if (auto *UO = dyn_cast<UnaryOperator>(S)) {
3352 if (UO->isIncrementDecrementOp() &&
3353 GetInitLCDecl(UO->getSubExpr()) == LCDecl)
3354 return SetStep(SemaRef
3355 .ActOnIntegerConstant(UO->getLocStart(),
3356 (UO->isDecrementOp() ? -1 : 1))
3359 } else if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3360 switch (BO->getOpcode()) {
3363 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3364 return SetStep(BO->getRHS(), BO->getOpcode() == BO_SubAssign);
3367 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3368 return CheckIncRHS(BO->getRHS());
3373 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3374 switch (CE->getOperator()) {
3377 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3378 return SetStep(SemaRef
3379 .ActOnIntegerConstant(
3381 ((CE->getOperator() == OO_MinusMinus) ? -1 : 1))
3387 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3388 return SetStep(CE->getArg(1), CE->getOperator() == OO_MinusEqual);
3391 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3392 return CheckIncRHS(CE->getArg(1));
3398 if (Dependent() || SemaRef.CurContext->isDependentContext())
3400 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_incr)
3401 << S->getSourceRange() << LCDecl;
3406 tryBuildCapture(Sema &SemaRef, Expr *Capture,
3407 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3408 if (SemaRef.CurContext->isDependentContext())
3409 return ExprResult(Capture);
3410 if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects))
3411 return SemaRef.PerformImplicitConversion(
3412 Capture->IgnoreImpCasts(), Capture->getType(), Sema::AA_Converting,
3413 /*AllowExplicit=*/true);
3414 auto I = Captures.find(Capture);
3415 if (I != Captures.end())
3416 return buildCapture(SemaRef, Capture, I->second);
3417 DeclRefExpr *Ref = nullptr;
3418 ExprResult Res = buildCapture(SemaRef, Capture, Ref);
3419 Captures[Capture] = Ref;
3423 /// \brief Build the expression to calculate the number of iterations.
3424 Expr *OpenMPIterationSpaceChecker::BuildNumIterations(
3425 Scope *S, const bool LimitedType,
3426 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
3428 auto VarType = LCDecl->getType().getNonReferenceType();
3429 if (VarType->isIntegerType() || VarType->isPointerType() ||
3430 SemaRef.getLangOpts().CPlusPlus) {
3432 auto *UBExpr = TestIsLessOp ? UB : LB;
3433 auto *LBExpr = TestIsLessOp ? LB : UB;
3434 Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get();
3435 Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get();
3436 if (!Upper || !Lower)
3439 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Sub, Upper, Lower);
3441 if (!Diff.isUsable() && VarType->getAsCXXRecordDecl()) {
3442 // BuildBinOp already emitted error, this one is to point user to upper
3443 // and lower bound, and to tell what is passed to 'operator-'.
3444 SemaRef.Diag(Upper->getLocStart(), diag::err_omp_loop_diff_cxx)
3445 << Upper->getSourceRange() << Lower->getSourceRange();
3450 if (!Diff.isUsable())
3453 // Upper - Lower [- 1]
3455 Diff = SemaRef.BuildBinOp(
3456 S, DefaultLoc, BO_Sub, Diff.get(),
3457 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3458 if (!Diff.isUsable())
3461 // Upper - Lower [- 1] + Step
3462 auto NewStep = tryBuildCapture(SemaRef, Step, Captures);
3463 if (!NewStep.isUsable())
3465 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Add, Diff.get(), NewStep.get());
3466 if (!Diff.isUsable())
3469 // Parentheses (for dumping/debugging purposes only).
3470 Diff = SemaRef.ActOnParenExpr(DefaultLoc, DefaultLoc, Diff.get());
3471 if (!Diff.isUsable())
3474 // (Upper - Lower [- 1] + Step) / Step
3475 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Div, Diff.get(), NewStep.get());
3476 if (!Diff.isUsable())
3479 // OpenMP runtime requires 32-bit or 64-bit loop variables.
3480 QualType Type = Diff.get()->getType();
3481 auto &C = SemaRef.Context;
3482 bool UseVarType = VarType->hasIntegerRepresentation() &&
3483 C.getTypeSize(Type) > C.getTypeSize(VarType);
3484 if (!Type->isIntegerType() || UseVarType) {
3486 UseVarType ? C.getTypeSize(VarType) : C.getTypeSize(Type);
3487 bool IsSigned = UseVarType ? VarType->hasSignedIntegerRepresentation()
3488 : Type->hasSignedIntegerRepresentation();
3489 Type = C.getIntTypeForBitwidth(NewSize, IsSigned);
3490 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), Type)) {
3491 Diff = SemaRef.PerformImplicitConversion(
3492 Diff.get(), Type, Sema::AA_Converting, /*AllowExplicit=*/true);
3493 if (!Diff.isUsable())
3498 unsigned NewSize = (C.getTypeSize(Type) > 32) ? 64 : 32;
3499 if (NewSize != C.getTypeSize(Type)) {
3500 if (NewSize < C.getTypeSize(Type)) {
3501 assert(NewSize == 64 && "incorrect loop var size");
3502 SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var)
3503 << InitSrcRange << ConditionSrcRange;
3505 QualType NewType = C.getIntTypeForBitwidth(
3506 NewSize, Type->hasSignedIntegerRepresentation() ||
3507 C.getTypeSize(Type) < NewSize);
3508 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), NewType)) {
3509 Diff = SemaRef.PerformImplicitConversion(Diff.get(), NewType,
3510 Sema::AA_Converting, true);
3511 if (!Diff.isUsable())
3520 Expr *OpenMPIterationSpaceChecker::BuildPreCond(
3521 Scope *S, Expr *Cond,
3522 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
3523 // Try to build LB <op> UB, where <op> is <, >, <=, or >=.
3524 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
3525 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
3527 auto NewLB = tryBuildCapture(SemaRef, LB, Captures);
3528 auto NewUB = tryBuildCapture(SemaRef, UB, Captures);
3529 if (!NewLB.isUsable() || !NewUB.isUsable())
3532 auto CondExpr = SemaRef.BuildBinOp(
3533 S, DefaultLoc, TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE)
3534 : (TestIsStrictOp ? BO_GT : BO_GE),
3535 NewLB.get(), NewUB.get());
3536 if (CondExpr.isUsable()) {
3537 if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(),
3538 SemaRef.Context.BoolTy))
3539 CondExpr = SemaRef.PerformImplicitConversion(
3540 CondExpr.get(), SemaRef.Context.BoolTy, /*Action=*/Sema::AA_Casting,
3541 /*AllowExplicit=*/true);
3543 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
3544 // Otherwise use original loop conditon and evaluate it in runtime.
3545 return CondExpr.isUsable() ? CondExpr.get() : Cond;
3548 /// \brief Build reference expression to the counter be used for codegen.
3549 DeclRefExpr *OpenMPIterationSpaceChecker::BuildCounterVar(
3550 llvm::MapVector<Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const {
3551 auto *VD = dyn_cast<VarDecl>(LCDecl);
3553 VD = SemaRef.IsOpenMPCapturedDecl(LCDecl);
3554 auto *Ref = buildDeclRefExpr(
3555 SemaRef, VD, VD->getType().getNonReferenceType(), DefaultLoc);
3556 DSAStackTy::DSAVarData Data = DSA.getTopDSA(LCDecl, /*FromParent=*/false);
3557 // If the loop control decl is explicitly marked as private, do not mark it
3558 // as captured again.
3559 if (!isOpenMPPrivate(Data.CKind) || !Data.RefExpr)
3560 Captures.insert(std::make_pair(LCRef, Ref));
3563 return buildDeclRefExpr(SemaRef, VD, VD->getType().getNonReferenceType(),
3567 Expr *OpenMPIterationSpaceChecker::BuildPrivateCounterVar() const {
3568 if (LCDecl && !LCDecl->isInvalidDecl()) {
3569 auto Type = LCDecl->getType().getNonReferenceType();
3571 buildVarDecl(SemaRef, DefaultLoc, Type, LCDecl->getName(),
3572 LCDecl->hasAttrs() ? &LCDecl->getAttrs() : nullptr);
3573 if (PrivateVar->isInvalidDecl())
3575 return buildDeclRefExpr(SemaRef, PrivateVar, Type, DefaultLoc);
3580 /// \brief Build initialization of the counter to be used for codegen.
3581 Expr *OpenMPIterationSpaceChecker::BuildCounterInit() const { return LB; }
3583 /// \brief Build step of the counter be used for codegen.
3584 Expr *OpenMPIterationSpaceChecker::BuildCounterStep() const { return Step; }
3586 /// \brief Iteration space of a single for loop.
3587 struct LoopIterationSpace final {
3588 /// \brief Condition of the loop.
3589 Expr *PreCond = nullptr;
3590 /// \brief This expression calculates the number of iterations in the loop.
3591 /// It is always possible to calculate it before starting the loop.
3592 Expr *NumIterations = nullptr;
3593 /// \brief The loop counter variable.
3594 Expr *CounterVar = nullptr;
3595 /// \brief Private loop counter variable.
3596 Expr *PrivateCounterVar = nullptr;
3597 /// \brief This is initializer for the initial value of #CounterVar.
3598 Expr *CounterInit = nullptr;
3599 /// \brief This is step for the #CounterVar used to generate its update:
3600 /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration.
3601 Expr *CounterStep = nullptr;
3602 /// \brief Should step be subtracted?
3603 bool Subtract = false;
3604 /// \brief Source range of the loop init.
3605 SourceRange InitSrcRange;
3606 /// \brief Source range of the loop condition.
3607 SourceRange CondSrcRange;
3608 /// \brief Source range of the loop increment.
3609 SourceRange IncSrcRange;
3614 void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) {
3615 assert(getLangOpts().OpenMP && "OpenMP is not active.");
3616 assert(Init && "Expected loop in canonical form.");
3617 unsigned AssociatedLoops = DSAStack->getAssociatedLoops();
3618 if (AssociatedLoops > 0 &&
3619 isOpenMPLoopDirective(DSAStack->getCurrentDirective())) {
3620 OpenMPIterationSpaceChecker ISC(*this, ForLoc);
3621 if (!ISC.CheckInit(Init, /*EmitDiags=*/false)) {
3622 if (auto *D = ISC.GetLoopDecl()) {
3623 auto *VD = dyn_cast<VarDecl>(D);
3625 if (auto *Private = IsOpenMPCapturedDecl(D))
3628 auto *Ref = buildCapture(*this, D, ISC.GetLoopDeclRefExpr(),
3629 /*WithInit=*/false);
3630 VD = cast<VarDecl>(Ref->getDecl());
3633 DSAStack->addLoopControlVariable(D, VD);
3636 DSAStack->setAssociatedLoops(AssociatedLoops - 1);
3640 /// \brief Called on a for stmt to check and extract its iteration space
3641 /// for further processing (such as collapsing).
3642 static bool CheckOpenMPIterationSpace(
3643 OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA,
3644 unsigned CurrentNestedLoopCount, unsigned NestedLoopCount,
3645 Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr,
3646 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
3647 LoopIterationSpace &ResultIterSpace,
3648 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3649 // OpenMP [2.6, Canonical Loop Form]
3650 // for (init-expr; test-expr; incr-expr) structured-block
3651 auto *For = dyn_cast_or_null<ForStmt>(S);
3653 SemaRef.Diag(S->getLocStart(), diag::err_omp_not_for)
3654 << (CollapseLoopCountExpr != nullptr || OrderedLoopCountExpr != nullptr)
3655 << getOpenMPDirectiveName(DKind) << NestedLoopCount
3656 << (CurrentNestedLoopCount > 0) << CurrentNestedLoopCount;
3657 if (NestedLoopCount > 1) {
3658 if (CollapseLoopCountExpr && OrderedLoopCountExpr)
3659 SemaRef.Diag(DSA.getConstructLoc(),
3660 diag::note_omp_collapse_ordered_expr)
3661 << 2 << CollapseLoopCountExpr->getSourceRange()
3662 << OrderedLoopCountExpr->getSourceRange();
3663 else if (CollapseLoopCountExpr)
3664 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
3665 diag::note_omp_collapse_ordered_expr)
3666 << 0 << CollapseLoopCountExpr->getSourceRange();
3668 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
3669 diag::note_omp_collapse_ordered_expr)
3670 << 1 << OrderedLoopCountExpr->getSourceRange();
3674 assert(For->getBody());
3676 OpenMPIterationSpaceChecker ISC(SemaRef, For->getForLoc());
3679 auto Init = For->getInit();
3680 if (ISC.CheckInit(Init))
3683 bool HasErrors = false;
3685 // Check loop variable's type.
3686 if (auto *LCDecl = ISC.GetLoopDecl()) {
3687 auto *LoopDeclRefExpr = ISC.GetLoopDeclRefExpr();
3689 // OpenMP [2.6, Canonical Loop Form]
3690 // Var is one of the following:
3691 // A variable of signed or unsigned integer type.
3692 // For C++, a variable of a random access iterator type.
3693 // For C, a variable of a pointer type.
3694 auto VarType = LCDecl->getType().getNonReferenceType();
3695 if (!VarType->isDependentType() && !VarType->isIntegerType() &&
3696 !VarType->isPointerType() &&
3697 !(SemaRef.getLangOpts().CPlusPlus && VarType->isOverloadableType())) {
3698 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_variable_type)
3699 << SemaRef.getLangOpts().CPlusPlus;
3703 // OpenMP, 2.14.1.1 Data-sharing Attribute Rules for Variables Referenced in
3705 // The loop iteration variable(s) in the associated for-loop(s) of a for or
3706 // parallel for construct is (are) private.
3707 // The loop iteration variable in the associated for-loop of a simd
3708 // construct with just one associated for-loop is linear with a
3709 // constant-linear-step that is the increment of the associated for-loop.
3710 // Exclude loop var from the list of variables with implicitly defined data
3711 // sharing attributes.
3712 VarsWithImplicitDSA.erase(LCDecl);
3714 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
3715 // in a Construct, C/C++].
3716 // The loop iteration variable in the associated for-loop of a simd
3717 // construct with just one associated for-loop may be listed in a linear
3718 // clause with a constant-linear-step that is the increment of the
3719 // associated for-loop.
3720 // The loop iteration variable(s) in the associated for-loop(s) of a for or
3721 // parallel for construct may be listed in a private or lastprivate clause.
3722 DSAStackTy::DSAVarData DVar = DSA.getTopDSA(LCDecl, false);
3723 // If LoopVarRefExpr is nullptr it means the corresponding loop variable is
3724 // declared in the loop and it is predetermined as a private.
3725 auto PredeterminedCKind =
3726 isOpenMPSimdDirective(DKind)
3727 ? ((NestedLoopCount == 1) ? OMPC_linear : OMPC_lastprivate)
3729 if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
3730 DVar.CKind != PredeterminedCKind) ||
3731 ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop ||
3732 isOpenMPDistributeDirective(DKind)) &&
3733 !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
3734 DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) &&
3735 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
3736 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_var_dsa)
3737 << getOpenMPClauseName(DVar.CKind) << getOpenMPDirectiveName(DKind)
3738 << getOpenMPClauseName(PredeterminedCKind);
3739 if (DVar.RefExpr == nullptr)
3740 DVar.CKind = PredeterminedCKind;
3741 ReportOriginalDSA(SemaRef, &DSA, LCDecl, DVar, /*IsLoopIterVar=*/true);
3743 } else if (LoopDeclRefExpr != nullptr) {
3744 // Make the loop iteration variable private (for worksharing constructs),
3745 // linear (for simd directives with the only one associated loop) or
3746 // lastprivate (for simd directives with several collapsed or ordered
3748 if (DVar.CKind == OMPC_unknown)
3749 DVar = DSA.hasDSA(LCDecl, isOpenMPPrivate,
3750 [](OpenMPDirectiveKind) -> bool { return true; },
3751 /*FromParent=*/false);
3752 DSA.addDSA(LCDecl, LoopDeclRefExpr, PredeterminedCKind);
3755 assert(isOpenMPLoopDirective(DKind) && "DSA for non-loop vars");
3758 HasErrors |= ISC.CheckCond(For->getCond());
3761 HasErrors |= ISC.CheckInc(For->getInc());
3764 if (ISC.Dependent() || SemaRef.CurContext->isDependentContext() || HasErrors)
3767 // Build the loop's iteration space representation.
3768 ResultIterSpace.PreCond =
3769 ISC.BuildPreCond(DSA.getCurScope(), For->getCond(), Captures);
3770 ResultIterSpace.NumIterations = ISC.BuildNumIterations(
3772 (isOpenMPWorksharingDirective(DKind) ||
3773 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)),
3775 ResultIterSpace.CounterVar = ISC.BuildCounterVar(Captures, DSA);
3776 ResultIterSpace.PrivateCounterVar = ISC.BuildPrivateCounterVar();
3777 ResultIterSpace.CounterInit = ISC.BuildCounterInit();
3778 ResultIterSpace.CounterStep = ISC.BuildCounterStep();
3779 ResultIterSpace.InitSrcRange = ISC.GetInitSrcRange();
3780 ResultIterSpace.CondSrcRange = ISC.GetConditionSrcRange();
3781 ResultIterSpace.IncSrcRange = ISC.GetIncrementSrcRange();
3782 ResultIterSpace.Subtract = ISC.ShouldSubtractStep();
3784 HasErrors |= (ResultIterSpace.PreCond == nullptr ||
3785 ResultIterSpace.NumIterations == nullptr ||
3786 ResultIterSpace.CounterVar == nullptr ||
3787 ResultIterSpace.PrivateCounterVar == nullptr ||
3788 ResultIterSpace.CounterInit == nullptr ||
3789 ResultIterSpace.CounterStep == nullptr);
3794 /// \brief Build 'VarRef = Start.
3796 BuildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef,
3798 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3799 // Build 'VarRef = Start.
3800 auto NewStart = tryBuildCapture(SemaRef, Start.get(), Captures);
3801 if (!NewStart.isUsable())
3803 if (!SemaRef.Context.hasSameType(NewStart.get()->getType(),
3804 VarRef.get()->getType())) {
3805 NewStart = SemaRef.PerformImplicitConversion(
3806 NewStart.get(), VarRef.get()->getType(), Sema::AA_Converting,
3807 /*AllowExplicit=*/true);
3808 if (!NewStart.isUsable())
3813 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
3817 /// \brief Build 'VarRef = Start + Iter * Step'.
3819 BuildCounterUpdate(Sema &SemaRef, Scope *S, SourceLocation Loc,
3820 ExprResult VarRef, ExprResult Start, ExprResult Iter,
3821 ExprResult Step, bool Subtract,
3822 llvm::MapVector<Expr *, DeclRefExpr *> *Captures = nullptr) {
3823 // Add parentheses (for debugging purposes only).
3824 Iter = SemaRef.ActOnParenExpr(Loc, Loc, Iter.get());
3825 if (!VarRef.isUsable() || !Start.isUsable() || !Iter.isUsable() ||
3829 ExprResult NewStep = Step;
3831 NewStep = tryBuildCapture(SemaRef, Step.get(), *Captures);
3832 if (NewStep.isInvalid())
3835 SemaRef.BuildBinOp(S, Loc, BO_Mul, Iter.get(), NewStep.get());
3836 if (!Update.isUsable())
3839 // Try to build 'VarRef = Start, VarRef (+|-)= Iter * Step' or
3840 // 'VarRef = Start (+|-) Iter * Step'.
3841 ExprResult NewStart = Start;
3843 NewStart = tryBuildCapture(SemaRef, Start.get(), *Captures);
3844 if (NewStart.isInvalid())
3847 // First attempt: try to build 'VarRef = Start, VarRef += Iter * Step'.
3848 ExprResult SavedUpdate = Update;
3849 ExprResult UpdateVal;
3850 if (VarRef.get()->getType()->isOverloadableType() ||
3851 NewStart.get()->getType()->isOverloadableType() ||
3852 Update.get()->getType()->isOverloadableType()) {
3853 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
3854 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
3856 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
3857 if (Update.isUsable()) {
3859 SemaRef.BuildBinOp(S, Loc, Subtract ? BO_SubAssign : BO_AddAssign,
3860 VarRef.get(), SavedUpdate.get());
3861 if (UpdateVal.isUsable()) {
3862 Update = SemaRef.CreateBuiltinBinOp(Loc, BO_Comma, Update.get(),
3866 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
3869 // Second attempt: try to build 'VarRef = Start (+|-) Iter * Step'.
3870 if (!Update.isUsable() || !UpdateVal.isUsable()) {
3871 Update = SemaRef.BuildBinOp(S, Loc, Subtract ? BO_Sub : BO_Add,
3872 NewStart.get(), SavedUpdate.get());
3873 if (!Update.isUsable())
3876 if (!SemaRef.Context.hasSameType(Update.get()->getType(),
3877 VarRef.get()->getType())) {
3878 Update = SemaRef.PerformImplicitConversion(
3879 Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true);
3880 if (!Update.isUsable())
3884 Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get());
3889 /// \brief Convert integer expression \a E to make it have at least \a Bits
3891 static ExprResult WidenIterationCount(unsigned Bits, Expr *E, Sema &SemaRef) {
3894 auto &C = SemaRef.Context;
3895 QualType OldType = E->getType();
3896 unsigned HasBits = C.getTypeSize(OldType);
3897 if (HasBits >= Bits)
3898 return ExprResult(E);
3899 // OK to convert to signed, because new type has more bits than old.
3900 QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
3901 return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
3905 /// \brief Check if the given expression \a E is a constant integer that fits
3906 /// into \a Bits bits.
3907 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
3910 llvm::APSInt Result;
3911 if (E->isIntegerConstantExpr(Result, SemaRef.Context))
3912 return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits);
3916 /// Build preinits statement for the given declarations.
3917 static Stmt *buildPreInits(ASTContext &Context,
3918 SmallVectorImpl<Decl *> &PreInits) {
3919 if (!PreInits.empty()) {
3920 return new (Context) DeclStmt(
3921 DeclGroupRef::Create(Context, PreInits.begin(), PreInits.size()),
3922 SourceLocation(), SourceLocation());
3927 /// Build preinits statement for the given declarations.
3928 static Stmt *buildPreInits(ASTContext &Context,
3929 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3930 if (!Captures.empty()) {
3931 SmallVector<Decl *, 16> PreInits;
3932 for (auto &Pair : Captures)
3933 PreInits.push_back(Pair.second->getDecl());
3934 return buildPreInits(Context, PreInits);
3939 /// Build postupdate expression for the given list of postupdates expressions.
3940 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
3941 Expr *PostUpdate = nullptr;
3942 if (!PostUpdates.empty()) {
3943 for (auto *E : PostUpdates) {
3944 Expr *ConvE = S.BuildCStyleCastExpr(
3946 S.Context.getTrivialTypeSourceInfo(S.Context.VoidTy),
3949 PostUpdate = PostUpdate
3950 ? S.CreateBuiltinBinOp(ConvE->getExprLoc(), BO_Comma,
3959 /// \brief Called on a for stmt to check itself and nested loops (if any).
3960 /// \return Returns 0 if one of the collapsed stmts is not canonical for loop,
3961 /// number of collapsed loops otherwise.
3963 CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
3964 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
3966 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
3967 OMPLoopDirective::HelperExprs &Built) {
3968 unsigned NestedLoopCount = 1;
3969 if (CollapseLoopCountExpr) {
3970 // Found 'collapse' clause - calculate collapse number.
3971 llvm::APSInt Result;
3972 if (CollapseLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext()))
3973 NestedLoopCount = Result.getLimitedValue();
3975 if (OrderedLoopCountExpr) {
3976 // Found 'ordered' clause - calculate collapse number.
3977 llvm::APSInt Result;
3978 if (OrderedLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) {
3979 if (Result.getLimitedValue() < NestedLoopCount) {
3980 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
3981 diag::err_omp_wrong_ordered_loop_count)
3982 << OrderedLoopCountExpr->getSourceRange();
3983 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
3984 diag::note_collapse_loop_count)
3985 << CollapseLoopCountExpr->getSourceRange();
3987 NestedLoopCount = Result.getLimitedValue();
3990 // This is helper routine for loop directives (e.g., 'for', 'simd',
3991 // 'for simd', etc.).
3992 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
3993 SmallVector<LoopIterationSpace, 4> IterSpaces;
3994 IterSpaces.resize(NestedLoopCount);
3995 Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true);
3996 for (unsigned Cnt = 0; Cnt < NestedLoopCount; ++Cnt) {
3997 if (CheckOpenMPIterationSpace(DKind, CurStmt, SemaRef, DSA, Cnt,
3998 NestedLoopCount, CollapseLoopCountExpr,
3999 OrderedLoopCountExpr, VarsWithImplicitDSA,
4000 IterSpaces[Cnt], Captures))
4002 // Move on to the next nested for loop, or to the loop body.
4003 // OpenMP [2.8.1, simd construct, Restrictions]
4004 // All loops associated with the construct must be perfectly nested; that
4005 // is, there must be no intervening code nor any OpenMP directive between
4007 CurStmt = cast<ForStmt>(CurStmt)->getBody()->IgnoreContainers();
4010 Built.clear(/* size */ NestedLoopCount);
4012 if (SemaRef.CurContext->isDependentContext())
4013 return NestedLoopCount;
4015 // An example of what is generated for the following code:
4017 // #pragma omp simd collapse(2) ordered(2)
4018 // for (i = 0; i < NI; ++i)
4019 // for (k = 0; k < NK; ++k)
4020 // for (j = J0; j < NJ; j+=2) {
4024 // We generate the code below.
4025 // Note: the loop body may be outlined in CodeGen.
4026 // Note: some counters may be C++ classes, operator- is used to find number of
4027 // iterations and operator+= to calculate counter value.
4028 // Note: decltype(NumIterations) must be integer type (in 'omp for', only i32
4029 // or i64 is currently supported).
4031 // #define NumIterations (NI * ((NJ - J0 - 1 + 2) / 2))
4032 // for (int[32|64]_t IV = 0; IV < NumIterations; ++IV ) {
4033 // .local.i = IV / ((NJ - J0 - 1 + 2) / 2);
4034 // .local.j = J0 + (IV % ((NJ - J0 - 1 + 2) / 2)) * 2;
4035 // // similar updates for vars in clauses (e.g. 'linear')
4036 // <loop body (using local i and j)>
4038 // i = NI; // assign final values of counters
4042 // Last iteration number is (I1 * I2 * ... In) - 1, where I1, I2 ... In are
4043 // the iteration counts of the collapsed for loops.
4044 // Precondition tests if there is at least one iteration (all conditions are
4046 auto PreCond = ExprResult(IterSpaces[0].PreCond);
4047 auto N0 = IterSpaces[0].NumIterations;
4048 ExprResult LastIteration32 = WidenIterationCount(
4049 32 /* Bits */, SemaRef
4050 .PerformImplicitConversion(
4051 N0->IgnoreImpCasts(), N0->getType(),
4052 Sema::AA_Converting, /*AllowExplicit=*/true)
4055 ExprResult LastIteration64 = WidenIterationCount(
4056 64 /* Bits */, SemaRef
4057 .PerformImplicitConversion(
4058 N0->IgnoreImpCasts(), N0->getType(),
4059 Sema::AA_Converting, /*AllowExplicit=*/true)
4063 if (!LastIteration32.isUsable() || !LastIteration64.isUsable())
4064 return NestedLoopCount;
4066 auto &C = SemaRef.Context;
4067 bool AllCountsNeedLessThan32Bits = C.getTypeSize(N0->getType()) < 32;
4069 Scope *CurScope = DSA.getCurScope();
4070 for (unsigned Cnt = 1; Cnt < NestedLoopCount; ++Cnt) {
4071 if (PreCond.isUsable()) {
4073 SemaRef.BuildBinOp(CurScope, PreCond.get()->getExprLoc(), BO_LAnd,
4074 PreCond.get(), IterSpaces[Cnt].PreCond);
4076 auto N = IterSpaces[Cnt].NumIterations;
4077 SourceLocation Loc = N->getExprLoc();
4078 AllCountsNeedLessThan32Bits &= C.getTypeSize(N->getType()) < 32;
4079 if (LastIteration32.isUsable())
4080 LastIteration32 = SemaRef.BuildBinOp(
4081 CurScope, Loc, BO_Mul, LastIteration32.get(),
4083 .PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
4084 Sema::AA_Converting,
4085 /*AllowExplicit=*/true)
4087 if (LastIteration64.isUsable())
4088 LastIteration64 = SemaRef.BuildBinOp(
4089 CurScope, Loc, BO_Mul, LastIteration64.get(),
4091 .PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
4092 Sema::AA_Converting,
4093 /*AllowExplicit=*/true)
4097 // Choose either the 32-bit or 64-bit version.
4098 ExprResult LastIteration = LastIteration64;
4099 if (LastIteration32.isUsable() &&
4100 C.getTypeSize(LastIteration32.get()->getType()) == 32 &&
4101 (AllCountsNeedLessThan32Bits || NestedLoopCount == 1 ||
4104 LastIteration32.get()->getType()->hasSignedIntegerRepresentation(),
4105 LastIteration64.get(), SemaRef)))
4106 LastIteration = LastIteration32;
4107 QualType VType = LastIteration.get()->getType();
4108 QualType RealVType = VType;
4109 QualType StrideVType = VType;
4110 if (isOpenMPTaskLoopDirective(DKind)) {
4112 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
4114 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
4117 if (!LastIteration.isUsable())
4120 // Save the number of iterations.
4121 ExprResult NumIterations = LastIteration;
4123 LastIteration = SemaRef.BuildBinOp(
4124 CurScope, LastIteration.get()->getExprLoc(), BO_Sub,
4125 LastIteration.get(),
4126 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
4127 if (!LastIteration.isUsable())
4131 // Calculate the last iteration number beforehand instead of doing this on
4132 // each iteration. Do not do this if the number of iterations may be kfold-ed.
4133 llvm::APSInt Result;
4135 LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context);
4136 ExprResult CalcLastIteration;
4138 ExprResult SaveRef =
4139 tryBuildCapture(SemaRef, LastIteration.get(), Captures);
4140 LastIteration = SaveRef;
4142 // Prepare SaveRef + 1.
4143 NumIterations = SemaRef.BuildBinOp(
4144 CurScope, SaveRef.get()->getExprLoc(), BO_Add, SaveRef.get(),
4145 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
4146 if (!NumIterations.isUsable())
4150 SourceLocation InitLoc = IterSpaces[0].InitSrcRange.getBegin();
4152 // Build variables passed into runtime, necessary for worksharing directives.
4153 ExprResult LB, UB, IL, ST, EUB, CombLB, CombUB, PrevLB, PrevUB, CombEUB;
4154 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
4155 isOpenMPDistributeDirective(DKind)) {
4156 // Lower bound variable, initialized with zero.
4157 VarDecl *LBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.lb");
4158 LB = buildDeclRefExpr(SemaRef, LBDecl, VType, InitLoc);
4159 SemaRef.AddInitializerToDecl(LBDecl,
4160 SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
4161 /*DirectInit*/ false);
4163 // Upper bound variable, initialized with last iteration number.
4164 VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
4165 UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
4166 SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
4167 /*DirectInit*/ false);
4169 // A 32-bit variable-flag where runtime returns 1 for the last iteration.
4170 // This will be used to implement clause 'lastprivate'.
4171 QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
4172 VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
4173 IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
4174 SemaRef.AddInitializerToDecl(ILDecl,
4175 SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
4176 /*DirectInit*/ false);
4178 // Stride variable returned by runtime (we initialize it to 1 by default).
4180 buildVarDecl(SemaRef, InitLoc, StrideVType, ".omp.stride");
4181 ST = buildDeclRefExpr(SemaRef, STDecl, StrideVType, InitLoc);
4182 SemaRef.AddInitializerToDecl(STDecl,
4183 SemaRef.ActOnIntegerConstant(InitLoc, 1).get(),
4184 /*DirectInit*/ false);
4186 // Build expression: UB = min(UB, LastIteration)
4187 // It is necessary for CodeGen of directives with static scheduling.
4188 ExprResult IsUBGreater = SemaRef.BuildBinOp(CurScope, InitLoc, BO_GT,
4189 UB.get(), LastIteration.get());
4190 ExprResult CondOp = SemaRef.ActOnConditionalOp(
4191 InitLoc, InitLoc, IsUBGreater.get(), LastIteration.get(), UB.get());
4192 EUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, UB.get(),
4194 EUB = SemaRef.ActOnFinishFullExpr(EUB.get());
4196 // If we have a combined directive that combines 'distribute', 'for' or
4197 // 'simd' we need to be able to access the bounds of the schedule of the
4198 // enclosing region. E.g. in 'distribute parallel for' the bounds obtained
4199 // by scheduling 'distribute' have to be passed to the schedule of 'for'.
4200 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4202 // Lower bound variable, initialized with zero.
4203 VarDecl *CombLBDecl =
4204 buildVarDecl(SemaRef, InitLoc, VType, ".omp.comb.lb");
4205 CombLB = buildDeclRefExpr(SemaRef, CombLBDecl, VType, InitLoc);
4206 SemaRef.AddInitializerToDecl(
4207 CombLBDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
4208 /*DirectInit*/ false);
4210 // Upper bound variable, initialized with last iteration number.
4211 VarDecl *CombUBDecl =
4212 buildVarDecl(SemaRef, InitLoc, VType, ".omp.comb.ub");
4213 CombUB = buildDeclRefExpr(SemaRef, CombUBDecl, VType, InitLoc);
4214 SemaRef.AddInitializerToDecl(CombUBDecl, LastIteration.get(),
4215 /*DirectInit*/ false);
4217 ExprResult CombIsUBGreater = SemaRef.BuildBinOp(
4218 CurScope, InitLoc, BO_GT, CombUB.get(), LastIteration.get());
4219 ExprResult CombCondOp =
4220 SemaRef.ActOnConditionalOp(InitLoc, InitLoc, CombIsUBGreater.get(),
4221 LastIteration.get(), CombUB.get());
4222 CombEUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, CombUB.get(),
4224 CombEUB = SemaRef.ActOnFinishFullExpr(CombEUB.get());
4226 auto *CD = cast<CapturedStmt>(AStmt)->getCapturedDecl();
4227 // We expect to have at least 2 more parameters than the 'parallel'
4228 // directive does - the lower and upper bounds of the previous schedule.
4229 assert(CD->getNumParams() >= 4 &&
4230 "Unexpected number of parameters in loop combined directive");
4232 // Set the proper type for the bounds given what we learned from the
4234 auto *PrevLBDecl = CD->getParam(/*PrevLB=*/2);
4235 auto *PrevUBDecl = CD->getParam(/*PrevUB=*/3);
4237 // Previous lower and upper bounds are obtained from the region
4240 buildDeclRefExpr(SemaRef, PrevLBDecl, PrevLBDecl->getType(), InitLoc);
4242 buildDeclRefExpr(SemaRef, PrevUBDecl, PrevUBDecl->getType(), InitLoc);
4246 // Build the iteration variable and its initialization before loop.
4248 ExprResult Init, CombInit;
4250 VarDecl *IVDecl = buildVarDecl(SemaRef, InitLoc, RealVType, ".omp.iv");
4251 IV = buildDeclRefExpr(SemaRef, IVDecl, RealVType, InitLoc);
4253 (isOpenMPWorksharingDirective(DKind) ||
4254 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
4256 : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
4257 Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS);
4258 Init = SemaRef.ActOnFinishFullExpr(Init.get());
4260 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4262 (isOpenMPWorksharingDirective(DKind) ||
4263 isOpenMPTaskLoopDirective(DKind) ||
4264 isOpenMPDistributeDirective(DKind))
4266 : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
4268 SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), CombRHS);
4269 CombInit = SemaRef.ActOnFinishFullExpr(CombInit.get());
4273 // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops.
4274 SourceLocation CondLoc;
4276 (isOpenMPWorksharingDirective(DKind) ||
4277 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
4278 ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get())
4279 : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(),
4280 NumIterations.get());
4281 ExprResult CombCond;
4282 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4284 SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), CombUB.get());
4286 // Loop increment (IV = IV + 1)
4287 SourceLocation IncLoc;
4289 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, IV.get(),
4290 SemaRef.ActOnIntegerConstant(IncLoc, 1).get());
4291 if (!Inc.isUsable())
4293 Inc = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, IV.get(), Inc.get());
4294 Inc = SemaRef.ActOnFinishFullExpr(Inc.get());
4295 if (!Inc.isUsable())
4298 // Increments for worksharing loops (LB = LB + ST; UB = UB + ST).
4299 // Used for directives with static scheduling.
4300 // In combined construct, add combined version that use CombLB and CombUB
4301 // base variables for the update
4302 ExprResult NextLB, NextUB, CombNextLB, CombNextUB;
4303 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
4304 isOpenMPDistributeDirective(DKind)) {
4306 NextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, LB.get(), ST.get());
4307 if (!NextLB.isUsable())
4311 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, LB.get(), NextLB.get());
4312 NextLB = SemaRef.ActOnFinishFullExpr(NextLB.get());
4313 if (!NextLB.isUsable())
4316 NextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, UB.get(), ST.get());
4317 if (!NextUB.isUsable())
4321 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, UB.get(), NextUB.get());
4322 NextUB = SemaRef.ActOnFinishFullExpr(NextUB.get());
4323 if (!NextUB.isUsable())
4325 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4327 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, CombLB.get(), ST.get());
4328 if (!NextLB.isUsable())
4331 CombNextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, CombLB.get(),
4333 CombNextLB = SemaRef.ActOnFinishFullExpr(CombNextLB.get());
4334 if (!CombNextLB.isUsable())
4338 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, CombUB.get(), ST.get());
4339 if (!CombNextUB.isUsable())
4342 CombNextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, CombUB.get(),
4344 CombNextUB = SemaRef.ActOnFinishFullExpr(CombNextUB.get());
4345 if (!CombNextUB.isUsable())
4350 // Create increment expression for distribute loop when combined in a same
4351 // directive with for as IV = IV + ST; ensure upper bound expression based
4352 // on PrevUB instead of NumIterations - used to implement 'for' when found
4353 // in combination with 'distribute', like in 'distribute parallel for'
4354 SourceLocation DistIncLoc;
4355 ExprResult DistCond, DistInc, PrevEUB;
4356 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4357 DistCond = SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get());
4358 assert(DistCond.isUsable() && "distribute cond expr was not built");
4361 SemaRef.BuildBinOp(CurScope, DistIncLoc, BO_Add, IV.get(), ST.get());
4362 assert(DistInc.isUsable() && "distribute inc expr was not built");
4363 DistInc = SemaRef.BuildBinOp(CurScope, DistIncLoc, BO_Assign, IV.get(),
4365 DistInc = SemaRef.ActOnFinishFullExpr(DistInc.get());
4366 assert(DistInc.isUsable() && "distribute inc expr was not built");
4368 // Build expression: UB = min(UB, prevUB) for #for in composite or combined
4370 SourceLocation DistEUBLoc;
4371 ExprResult IsUBGreater =
4372 SemaRef.BuildBinOp(CurScope, DistEUBLoc, BO_GT, UB.get(), PrevUB.get());
4373 ExprResult CondOp = SemaRef.ActOnConditionalOp(
4374 DistEUBLoc, DistEUBLoc, IsUBGreater.get(), PrevUB.get(), UB.get());
4375 PrevEUB = SemaRef.BuildBinOp(CurScope, DistIncLoc, BO_Assign, UB.get(),
4377 PrevEUB = SemaRef.ActOnFinishFullExpr(PrevEUB.get());
4380 // Build updates and final values of the loop counters.
4381 bool HasErrors = false;
4382 Built.Counters.resize(NestedLoopCount);
4383 Built.Inits.resize(NestedLoopCount);
4384 Built.Updates.resize(NestedLoopCount);
4385 Built.Finals.resize(NestedLoopCount);
4386 SmallVector<Expr *, 4> LoopMultipliers;
4389 // Go from inner nested loop to outer.
4390 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
4391 LoopIterationSpace &IS = IterSpaces[Cnt];
4392 SourceLocation UpdLoc = IS.IncSrcRange.getBegin();
4393 // Build: Iter = (IV / Div) % IS.NumIters
4394 // where Div is product of previous iterations' IS.NumIters.
4396 if (Div.isUsable()) {
4398 SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Div, IV.get(), Div.get());
4401 assert((Cnt == (int)NestedLoopCount - 1) &&
4402 "unusable div expected on first iteration only");
4405 if (Cnt != 0 && Iter.isUsable())
4406 Iter = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Rem, Iter.get(),
4408 if (!Iter.isUsable()) {
4413 // Build update: IS.CounterVar(Private) = IS.Start + Iter * IS.Step
4414 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IS.CounterVar)->getDecl());
4415 auto *CounterVar = buildDeclRefExpr(SemaRef, VD, IS.CounterVar->getType(),
4416 IS.CounterVar->getExprLoc(),
4417 /*RefersToCapture=*/true);
4418 ExprResult Init = BuildCounterInit(SemaRef, CurScope, UpdLoc, CounterVar,
4419 IS.CounterInit, Captures);
4420 if (!Init.isUsable()) {
4424 ExprResult Update = BuildCounterUpdate(
4425 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, Iter,
4426 IS.CounterStep, IS.Subtract, &Captures);
4427 if (!Update.isUsable()) {
4432 // Build final: IS.CounterVar = IS.Start + IS.NumIters * IS.Step
4433 ExprResult Final = BuildCounterUpdate(
4434 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit,
4435 IS.NumIterations, IS.CounterStep, IS.Subtract, &Captures);
4436 if (!Final.isUsable()) {
4441 // Build Div for the next iteration: Div <- Div * IS.NumIters
4444 Div = IS.NumIterations;
4446 Div = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Mul, Div.get(),
4449 // Add parentheses (for debugging purposes only).
4451 Div = tryBuildCapture(SemaRef, Div.get(), Captures);
4452 if (!Div.isUsable()) {
4456 LoopMultipliers.push_back(Div.get());
4458 if (!Update.isUsable() || !Final.isUsable()) {
4463 Built.Counters[Cnt] = IS.CounterVar;
4464 Built.PrivateCounters[Cnt] = IS.PrivateCounterVar;
4465 Built.Inits[Cnt] = Init.get();
4466 Built.Updates[Cnt] = Update.get();
4467 Built.Finals[Cnt] = Final.get();
4475 Built.IterationVarRef = IV.get();
4476 Built.LastIteration = LastIteration.get();
4477 Built.NumIterations = NumIterations.get();
4478 Built.CalcLastIteration =
4479 SemaRef.ActOnFinishFullExpr(CalcLastIteration.get()).get();
4480 Built.PreCond = PreCond.get();
4481 Built.PreInits = buildPreInits(C, Captures);
4482 Built.Cond = Cond.get();
4483 Built.Init = Init.get();
4484 Built.Inc = Inc.get();
4485 Built.LB = LB.get();
4486 Built.UB = UB.get();
4487 Built.IL = IL.get();
4488 Built.ST = ST.get();
4489 Built.EUB = EUB.get();
4490 Built.NLB = NextLB.get();
4491 Built.NUB = NextUB.get();
4492 Built.PrevLB = PrevLB.get();
4493 Built.PrevUB = PrevUB.get();
4494 Built.DistInc = DistInc.get();
4495 Built.PrevEUB = PrevEUB.get();
4496 Built.DistCombinedFields.LB = CombLB.get();
4497 Built.DistCombinedFields.UB = CombUB.get();
4498 Built.DistCombinedFields.EUB = CombEUB.get();
4499 Built.DistCombinedFields.Init = CombInit.get();
4500 Built.DistCombinedFields.Cond = CombCond.get();
4501 Built.DistCombinedFields.NLB = CombNextLB.get();
4502 Built.DistCombinedFields.NUB = CombNextUB.get();
4504 Expr *CounterVal = SemaRef.DefaultLvalueConversion(IV.get()).get();
4505 // Fill data for doacross depend clauses.
4506 for (auto Pair : DSA.getDoacrossDependClauses()) {
4507 if (Pair.first->getDependencyKind() == OMPC_DEPEND_source)
4508 Pair.first->setCounterValue(CounterVal);
4510 if (NestedLoopCount != Pair.second.size() ||
4511 NestedLoopCount != LoopMultipliers.size() + 1) {
4512 // Erroneous case - clause has some problems.
4513 Pair.first->setCounterValue(CounterVal);
4516 assert(Pair.first->getDependencyKind() == OMPC_DEPEND_sink);
4517 auto I = Pair.second.rbegin();
4518 auto IS = IterSpaces.rbegin();
4519 auto ILM = LoopMultipliers.rbegin();
4520 Expr *UpCounterVal = CounterVal;
4521 Expr *Multiplier = nullptr;
4522 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
4524 assert(IS->CounterStep);
4525 Expr *NormalizedOffset =
4527 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Div,
4528 I->first, IS->CounterStep)
4533 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Mul,
4534 NormalizedOffset, Multiplier)
4537 assert(I->second == OO_Plus || I->second == OO_Minus);
4538 BinaryOperatorKind BOK = (I->second == OO_Plus) ? BO_Add : BO_Sub;
4539 UpCounterVal = SemaRef
4540 .BuildBinOp(CurScope, I->first->getExprLoc(), BOK,
4541 UpCounterVal, NormalizedOffset)
4549 Pair.first->setCounterValue(UpCounterVal);
4553 return NestedLoopCount;
4556 static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) {
4557 auto CollapseClauses =
4558 OMPExecutableDirective::getClausesOfKind<OMPCollapseClause>(Clauses);
4559 if (CollapseClauses.begin() != CollapseClauses.end())
4560 return (*CollapseClauses.begin())->getNumForLoops();
4564 static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) {
4565 auto OrderedClauses =
4566 OMPExecutableDirective::getClausesOfKind<OMPOrderedClause>(Clauses);
4567 if (OrderedClauses.begin() != OrderedClauses.end())
4568 return (*OrderedClauses.begin())->getNumForLoops();
4572 static bool checkSimdlenSafelenSpecified(Sema &S,
4573 const ArrayRef<OMPClause *> Clauses) {
4574 OMPSafelenClause *Safelen = nullptr;
4575 OMPSimdlenClause *Simdlen = nullptr;
4577 for (auto *Clause : Clauses) {
4578 if (Clause->getClauseKind() == OMPC_safelen)
4579 Safelen = cast<OMPSafelenClause>(Clause);
4580 else if (Clause->getClauseKind() == OMPC_simdlen)
4581 Simdlen = cast<OMPSimdlenClause>(Clause);
4582 if (Safelen && Simdlen)
4586 if (Simdlen && Safelen) {
4587 llvm::APSInt SimdlenRes, SafelenRes;
4588 auto SimdlenLength = Simdlen->getSimdlen();
4589 auto SafelenLength = Safelen->getSafelen();
4590 if (SimdlenLength->isValueDependent() || SimdlenLength->isTypeDependent() ||
4591 SimdlenLength->isInstantiationDependent() ||
4592 SimdlenLength->containsUnexpandedParameterPack())
4594 if (SafelenLength->isValueDependent() || SafelenLength->isTypeDependent() ||
4595 SafelenLength->isInstantiationDependent() ||
4596 SafelenLength->containsUnexpandedParameterPack())
4598 SimdlenLength->EvaluateAsInt(SimdlenRes, S.Context);
4599 SafelenLength->EvaluateAsInt(SafelenRes, S.Context);
4600 // OpenMP 4.5 [2.8.1, simd Construct, Restrictions]
4601 // If both simdlen and safelen clauses are specified, the value of the
4602 // simdlen parameter must be less than or equal to the value of the safelen
4604 if (SimdlenRes > SafelenRes) {
4605 S.Diag(SimdlenLength->getExprLoc(),
4606 diag::err_omp_wrong_simdlen_safelen_values)
4607 << SimdlenLength->getSourceRange() << SafelenLength->getSourceRange();
4614 StmtResult Sema::ActOnOpenMPSimdDirective(
4615 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4616 SourceLocation EndLoc,
4617 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4621 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4622 OMPLoopDirective::HelperExprs B;
4623 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4624 // define the nested loops number.
4625 unsigned NestedLoopCount = CheckOpenMPLoop(
4626 OMPD_simd, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
4627 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
4628 if (NestedLoopCount == 0)
4631 assert((CurContext->isDependentContext() || B.builtAll()) &&
4632 "omp simd loop exprs were not built");
4634 if (!CurContext->isDependentContext()) {
4635 // Finalize the clauses that need pre-built expressions for CodeGen.
4636 for (auto C : Clauses) {
4637 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4638 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4639 B.NumIterations, *this, CurScope,
4645 if (checkSimdlenSafelenSpecified(*this, Clauses))
4648 getCurFunction()->setHasBranchProtectedScope();
4649 return OMPSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4653 StmtResult Sema::ActOnOpenMPForDirective(
4654 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4655 SourceLocation EndLoc,
4656 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4660 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4661 OMPLoopDirective::HelperExprs B;
4662 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4663 // define the nested loops number.
4664 unsigned NestedLoopCount = CheckOpenMPLoop(
4665 OMPD_for, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
4666 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B);
4667 if (NestedLoopCount == 0)
4670 assert((CurContext->isDependentContext() || B.builtAll()) &&
4671 "omp for loop exprs were not built");
4673 if (!CurContext->isDependentContext()) {
4674 // Finalize the clauses that need pre-built expressions for CodeGen.
4675 for (auto C : Clauses) {
4676 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4677 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4678 B.NumIterations, *this, CurScope,
4684 getCurFunction()->setHasBranchProtectedScope();
4685 return OMPForDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4686 Clauses, AStmt, B, DSAStack->isCancelRegion());
4689 StmtResult Sema::ActOnOpenMPForSimdDirective(
4690 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4691 SourceLocation EndLoc,
4692 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4696 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4697 OMPLoopDirective::HelperExprs B;
4698 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4699 // define the nested loops number.
4700 unsigned NestedLoopCount =
4701 CheckOpenMPLoop(OMPD_for_simd, getCollapseNumberExpr(Clauses),
4702 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
4703 VarsWithImplicitDSA, B);
4704 if (NestedLoopCount == 0)
4707 assert((CurContext->isDependentContext() || B.builtAll()) &&
4708 "omp for simd loop exprs were not built");
4710 if (!CurContext->isDependentContext()) {
4711 // Finalize the clauses that need pre-built expressions for CodeGen.
4712 for (auto C : Clauses) {
4713 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4714 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4715 B.NumIterations, *this, CurScope,
4721 if (checkSimdlenSafelenSpecified(*this, Clauses))
4724 getCurFunction()->setHasBranchProtectedScope();
4725 return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4729 StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
4731 SourceLocation StartLoc,
4732 SourceLocation EndLoc) {
4736 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4737 auto BaseStmt = AStmt;
4738 while (auto *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
4739 BaseStmt = CS->getCapturedStmt();
4740 if (auto *C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
4741 auto S = C->children();
4742 if (S.begin() == S.end())
4744 // All associated statements must be '#pragma omp section' except for
4746 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
4747 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
4749 Diag(SectionStmt->getLocStart(),
4750 diag::err_omp_sections_substmt_not_section);
4753 cast<OMPSectionDirective>(SectionStmt)
4754 ->setHasCancel(DSAStack->isCancelRegion());
4757 Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt);
4761 getCurFunction()->setHasBranchProtectedScope();
4763 return OMPSectionsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
4764 DSAStack->isCancelRegion());
4767 StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
4768 SourceLocation StartLoc,
4769 SourceLocation EndLoc) {
4773 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4775 getCurFunction()->setHasBranchProtectedScope();
4776 DSAStack->setParentCancelRegion(DSAStack->isCancelRegion());
4778 return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt,
4779 DSAStack->isCancelRegion());
4782 StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
4784 SourceLocation StartLoc,
4785 SourceLocation EndLoc) {
4789 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4791 getCurFunction()->setHasBranchProtectedScope();
4793 // OpenMP [2.7.3, single Construct, Restrictions]
4794 // The copyprivate clause must not be used with the nowait clause.
4795 OMPClause *Nowait = nullptr;
4796 OMPClause *Copyprivate = nullptr;
4797 for (auto *Clause : Clauses) {
4798 if (Clause->getClauseKind() == OMPC_nowait)
4800 else if (Clause->getClauseKind() == OMPC_copyprivate)
4801 Copyprivate = Clause;
4802 if (Copyprivate && Nowait) {
4803 Diag(Copyprivate->getLocStart(),
4804 diag::err_omp_single_copyprivate_with_nowait);
4805 Diag(Nowait->getLocStart(), diag::note_omp_nowait_clause_here);
4810 return OMPSingleDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
4813 StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
4814 SourceLocation StartLoc,
4815 SourceLocation EndLoc) {
4819 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4821 getCurFunction()->setHasBranchProtectedScope();
4823 return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt);
4826 StmtResult Sema::ActOnOpenMPCriticalDirective(
4827 const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses,
4828 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
4832 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4834 bool ErrorFound = false;
4836 SourceLocation HintLoc;
4837 bool DependentHint = false;
4838 for (auto *C : Clauses) {
4839 if (C->getClauseKind() == OMPC_hint) {
4840 if (!DirName.getName()) {
4841 Diag(C->getLocStart(), diag::err_omp_hint_clause_no_name);
4844 Expr *E = cast<OMPHintClause>(C)->getHint();
4845 if (E->isTypeDependent() || E->isValueDependent() ||
4846 E->isInstantiationDependent())
4847 DependentHint = true;
4849 Hint = E->EvaluateKnownConstInt(Context);
4850 HintLoc = C->getLocStart();
4856 auto Pair = DSAStack->getCriticalWithHint(DirName);
4857 if (Pair.first && DirName.getName() && !DependentHint) {
4858 if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {
4859 Diag(StartLoc, diag::err_omp_critical_with_hint);
4860 if (HintLoc.isValid()) {
4861 Diag(HintLoc, diag::note_omp_critical_hint_here)
4862 << 0 << Hint.toString(/*Radix=*/10, /*Signed=*/false);
4864 Diag(StartLoc, diag::note_omp_critical_no_hint) << 0;
4865 if (auto *C = Pair.first->getSingleClause<OMPHintClause>()) {
4866 Diag(C->getLocStart(), diag::note_omp_critical_hint_here)
4868 << C->getHint()->EvaluateKnownConstInt(Context).toString(
4869 /*Radix=*/10, /*Signed=*/false);
4871 Diag(Pair.first->getLocStart(), diag::note_omp_critical_no_hint) << 1;
4875 getCurFunction()->setHasBranchProtectedScope();
4877 auto *Dir = OMPCriticalDirective::Create(Context, DirName, StartLoc, EndLoc,
4879 if (!Pair.first && DirName.getName() && !DependentHint)
4880 DSAStack->addCriticalWithHint(Dir, Hint);
4884 StmtResult Sema::ActOnOpenMPParallelForDirective(
4885 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4886 SourceLocation EndLoc,
4887 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4891 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
4892 // 1.2.2 OpenMP Language Terminology
4893 // Structured block - An executable statement with a single entry at the
4894 // top and a single exit at the bottom.
4895 // The point of exit cannot be a branch out of the structured block.
4896 // longjmp() and throw() must not violate the entry/exit criteria.
4897 CS->getCapturedDecl()->setNothrow();
4899 OMPLoopDirective::HelperExprs B;
4900 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4901 // define the nested loops number.
4902 unsigned NestedLoopCount =
4903 CheckOpenMPLoop(OMPD_parallel_for, getCollapseNumberExpr(Clauses),
4904 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
4905 VarsWithImplicitDSA, B);
4906 if (NestedLoopCount == 0)
4909 assert((CurContext->isDependentContext() || B.builtAll()) &&
4910 "omp parallel for loop exprs were not built");
4912 if (!CurContext->isDependentContext()) {
4913 // Finalize the clauses that need pre-built expressions for CodeGen.
4914 for (auto C : Clauses) {
4915 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4916 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4917 B.NumIterations, *this, CurScope,
4923 getCurFunction()->setHasBranchProtectedScope();
4924 return OMPParallelForDirective::Create(Context, StartLoc, EndLoc,
4925 NestedLoopCount, Clauses, AStmt, B,
4926 DSAStack->isCancelRegion());
4929 StmtResult Sema::ActOnOpenMPParallelForSimdDirective(
4930 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4931 SourceLocation EndLoc,
4932 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4936 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
4937 // 1.2.2 OpenMP Language Terminology
4938 // Structured block - An executable statement with a single entry at the
4939 // top and a single exit at the bottom.
4940 // The point of exit cannot be a branch out of the structured block.
4941 // longjmp() and throw() must not violate the entry/exit criteria.
4942 CS->getCapturedDecl()->setNothrow();
4944 OMPLoopDirective::HelperExprs B;
4945 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4946 // define the nested loops number.
4947 unsigned NestedLoopCount =
4948 CheckOpenMPLoop(OMPD_parallel_for_simd, getCollapseNumberExpr(Clauses),
4949 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
4950 VarsWithImplicitDSA, B);
4951 if (NestedLoopCount == 0)
4954 if (!CurContext->isDependentContext()) {
4955 // Finalize the clauses that need pre-built expressions for CodeGen.
4956 for (auto C : Clauses) {
4957 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4958 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4959 B.NumIterations, *this, CurScope,
4965 if (checkSimdlenSafelenSpecified(*this, Clauses))
4968 getCurFunction()->setHasBranchProtectedScope();
4969 return OMPParallelForSimdDirective::Create(
4970 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
4974 Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
4975 Stmt *AStmt, SourceLocation StartLoc,
4976 SourceLocation EndLoc) {
4980 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
4981 auto BaseStmt = AStmt;
4982 while (auto *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
4983 BaseStmt = CS->getCapturedStmt();
4984 if (auto *C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
4985 auto S = C->children();
4986 if (S.begin() == S.end())
4988 // All associated statements must be '#pragma omp section' except for
4990 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
4991 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
4993 Diag(SectionStmt->getLocStart(),
4994 diag::err_omp_parallel_sections_substmt_not_section);
4997 cast<OMPSectionDirective>(SectionStmt)
4998 ->setHasCancel(DSAStack->isCancelRegion());
5001 Diag(AStmt->getLocStart(),
5002 diag::err_omp_parallel_sections_not_compound_stmt);
5006 getCurFunction()->setHasBranchProtectedScope();
5008 return OMPParallelSectionsDirective::Create(
5009 Context, StartLoc, EndLoc, Clauses, AStmt, DSAStack->isCancelRegion());
5012 StmtResult Sema::ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
5013 Stmt *AStmt, SourceLocation StartLoc,
5014 SourceLocation EndLoc) {
5018 auto *CS = cast<CapturedStmt>(AStmt);
5019 // 1.2.2 OpenMP Language Terminology
5020 // Structured block - An executable statement with a single entry at the
5021 // top and a single exit at the bottom.
5022 // The point of exit cannot be a branch out of the structured block.
5023 // longjmp() and throw() must not violate the entry/exit criteria.
5024 CS->getCapturedDecl()->setNothrow();
5026 getCurFunction()->setHasBranchProtectedScope();
5028 return OMPTaskDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5029 DSAStack->isCancelRegion());
5032 StmtResult Sema::ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
5033 SourceLocation EndLoc) {
5034 return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc);
5037 StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
5038 SourceLocation EndLoc) {
5039 return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
5042 StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
5043 SourceLocation EndLoc) {
5044 return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc);
5047 StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt,
5048 SourceLocation StartLoc,
5049 SourceLocation EndLoc) {
5053 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5055 getCurFunction()->setHasBranchProtectedScope();
5057 return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt);
5060 StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
5061 SourceLocation StartLoc,
5062 SourceLocation EndLoc) {
5063 assert(Clauses.size() <= 1 && "Extra clauses in flush directive");
5064 return OMPFlushDirective::Create(Context, StartLoc, EndLoc, Clauses);
5067 StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
5069 SourceLocation StartLoc,
5070 SourceLocation EndLoc) {
5071 OMPClause *DependFound = nullptr;
5072 OMPClause *DependSourceClause = nullptr;
5073 OMPClause *DependSinkClause = nullptr;
5074 bool ErrorFound = false;
5075 OMPThreadsClause *TC = nullptr;
5076 OMPSIMDClause *SC = nullptr;
5077 for (auto *C : Clauses) {
5078 if (auto *DC = dyn_cast<OMPDependClause>(C)) {
5080 if (DC->getDependencyKind() == OMPC_DEPEND_source) {
5081 if (DependSourceClause) {
5082 Diag(C->getLocStart(), diag::err_omp_more_one_clause)
5083 << getOpenMPDirectiveName(OMPD_ordered)
5084 << getOpenMPClauseName(OMPC_depend) << 2;
5087 DependSourceClause = C;
5088 if (DependSinkClause) {
5089 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
5093 } else if (DC->getDependencyKind() == OMPC_DEPEND_sink) {
5094 if (DependSourceClause) {
5095 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
5099 DependSinkClause = C;
5101 } else if (C->getClauseKind() == OMPC_threads)
5102 TC = cast<OMPThreadsClause>(C);
5103 else if (C->getClauseKind() == OMPC_simd)
5104 SC = cast<OMPSIMDClause>(C);
5106 if (!ErrorFound && !SC &&
5107 isOpenMPSimdDirective(DSAStack->getParentDirective())) {
5108 // OpenMP [2.8.1,simd Construct, Restrictions]
5109 // An ordered construct with the simd clause is the only OpenMP construct
5110 // that can appear in the simd region.
5111 Diag(StartLoc, diag::err_omp_prohibited_region_simd);
5113 } else if (DependFound && (TC || SC)) {
5114 Diag(DependFound->getLocStart(), diag::err_omp_depend_clause_thread_simd)
5115 << getOpenMPClauseName(TC ? TC->getClauseKind() : SC->getClauseKind());
5117 } else if (DependFound && !DSAStack->getParentOrderedRegionParam()) {
5118 Diag(DependFound->getLocStart(),
5119 diag::err_omp_ordered_directive_without_param);
5121 } else if (TC || Clauses.empty()) {
5122 if (auto *Param = DSAStack->getParentOrderedRegionParam()) {
5123 SourceLocation ErrLoc = TC ? TC->getLocStart() : StartLoc;
5124 Diag(ErrLoc, diag::err_omp_ordered_directive_with_param)
5126 Diag(Param->getLocStart(), diag::note_omp_ordered_param);
5130 if ((!AStmt && !DependFound) || ErrorFound)
5134 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5136 getCurFunction()->setHasBranchProtectedScope();
5139 return OMPOrderedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5143 /// \brief Helper class for checking expression in 'omp atomic [update]'
5145 class OpenMPAtomicUpdateChecker {
5146 /// \brief Error results for atomic update expressions.
5147 enum ExprAnalysisErrorCode {
5148 /// \brief A statement is not an expression statement.
5150 /// \brief Expression is not builtin binary or unary operation.
5151 NotABinaryOrUnaryExpression,
5152 /// \brief Unary operation is not post-/pre- increment/decrement operation.
5153 NotAnUnaryIncDecExpression,
5154 /// \brief An expression is not of scalar type.
5156 /// \brief A binary operation is not an assignment operation.
5158 /// \brief RHS part of the binary operation is not a binary expression.
5159 NotABinaryExpression,
5160 /// \brief RHS part is not additive/multiplicative/shift/biwise binary
5163 /// \brief RHS binary operation does not have reference to the updated LHS
5165 NotAnUpdateExpression,
5166 /// \brief No errors is found.
5169 /// \brief Reference to Sema.
5171 /// \brief A location for note diagnostics (when error is found).
5172 SourceLocation NoteLoc;
5173 /// \brief 'x' lvalue part of the source atomic expression.
5175 /// \brief 'expr' rvalue part of the source atomic expression.
5177 /// \brief Helper expression of the form
5178 /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
5179 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
5181 /// \brief Is 'x' a LHS in a RHS part of full update expression. It is
5182 /// important for non-associative operations.
5183 bool IsXLHSInRHSPart;
5184 BinaryOperatorKind Op;
5185 SourceLocation OpLoc;
5186 /// \brief true if the source expression is a postfix unary operation, false
5187 /// if it is a prefix unary operation.
5188 bool IsPostfixUpdate;
5191 OpenMPAtomicUpdateChecker(Sema &SemaRef)
5192 : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr),
5193 IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {}
5194 /// \brief Check specified statement that it is suitable for 'atomic update'
5195 /// constructs and extract 'x', 'expr' and Operation from the original
5196 /// expression. If DiagId and NoteId == 0, then only check is performed
5197 /// without error notification.
5198 /// \param DiagId Diagnostic which should be emitted if error is found.
5199 /// \param NoteId Diagnostic note for the main error message.
5200 /// \return true if statement is not an update expression, false otherwise.
5201 bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0);
5202 /// \brief Return the 'x' lvalue part of the source atomic expression.
5203 Expr *getX() const { return X; }
5204 /// \brief Return the 'expr' rvalue part of the source atomic expression.
5205 Expr *getExpr() const { return E; }
5206 /// \brief Return the update expression used in calculation of the updated
5207 /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
5208 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
5209 Expr *getUpdateExpr() const { return UpdateExpr; }
5210 /// \brief Return true if 'x' is LHS in RHS part of full update expression,
5211 /// false otherwise.
5212 bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
5214 /// \brief true if the source expression is a postfix unary operation, false
5215 /// if it is a prefix unary operation.
5216 bool isPostfixUpdate() const { return IsPostfixUpdate; }
5219 bool checkBinaryOperation(BinaryOperator *AtomicBinOp, unsigned DiagId = 0,
5220 unsigned NoteId = 0);
5224 bool OpenMPAtomicUpdateChecker::checkBinaryOperation(
5225 BinaryOperator *AtomicBinOp, unsigned DiagId, unsigned NoteId) {
5226 ExprAnalysisErrorCode ErrorFound = NoError;
5227 SourceLocation ErrorLoc, NoteLoc;
5228 SourceRange ErrorRange, NoteRange;
5229 // Allowed constructs are:
5230 // x = x binop expr;
5231 // x = expr binop x;
5232 if (AtomicBinOp->getOpcode() == BO_Assign) {
5233 X = AtomicBinOp->getLHS();
5234 if (auto *AtomicInnerBinOp = dyn_cast<BinaryOperator>(
5235 AtomicBinOp->getRHS()->IgnoreParenImpCasts())) {
5236 if (AtomicInnerBinOp->isMultiplicativeOp() ||
5237 AtomicInnerBinOp->isAdditiveOp() || AtomicInnerBinOp->isShiftOp() ||
5238 AtomicInnerBinOp->isBitwiseOp()) {
5239 Op = AtomicInnerBinOp->getOpcode();
5240 OpLoc = AtomicInnerBinOp->getOperatorLoc();
5241 auto *LHS = AtomicInnerBinOp->getLHS();
5242 auto *RHS = AtomicInnerBinOp->getRHS();
5243 llvm::FoldingSetNodeID XId, LHSId, RHSId;
5244 X->IgnoreParenImpCasts()->Profile(XId, SemaRef.getASTContext(),
5245 /*Canonical=*/true);
5246 LHS->IgnoreParenImpCasts()->Profile(LHSId, SemaRef.getASTContext(),
5247 /*Canonical=*/true);
5248 RHS->IgnoreParenImpCasts()->Profile(RHSId, SemaRef.getASTContext(),
5249 /*Canonical=*/true);
5252 IsXLHSInRHSPart = true;
5253 } else if (XId == RHSId) {
5255 IsXLHSInRHSPart = false;
5257 ErrorLoc = AtomicInnerBinOp->getExprLoc();
5258 ErrorRange = AtomicInnerBinOp->getSourceRange();
5259 NoteLoc = X->getExprLoc();
5260 NoteRange = X->getSourceRange();
5261 ErrorFound = NotAnUpdateExpression;
5264 ErrorLoc = AtomicInnerBinOp->getExprLoc();
5265 ErrorRange = AtomicInnerBinOp->getSourceRange();
5266 NoteLoc = AtomicInnerBinOp->getOperatorLoc();
5267 NoteRange = SourceRange(NoteLoc, NoteLoc);
5268 ErrorFound = NotABinaryOperator;
5271 NoteLoc = ErrorLoc = AtomicBinOp->getRHS()->getExprLoc();
5272 NoteRange = ErrorRange = AtomicBinOp->getRHS()->getSourceRange();
5273 ErrorFound = NotABinaryExpression;
5276 ErrorLoc = AtomicBinOp->getExprLoc();
5277 ErrorRange = AtomicBinOp->getSourceRange();
5278 NoteLoc = AtomicBinOp->getOperatorLoc();
5279 NoteRange = SourceRange(NoteLoc, NoteLoc);
5280 ErrorFound = NotAnAssignmentOp;
5282 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
5283 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
5284 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
5286 } else if (SemaRef.CurContext->isDependentContext())
5287 E = X = UpdateExpr = nullptr;
5288 return ErrorFound != NoError;
5291 bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
5293 ExprAnalysisErrorCode ErrorFound = NoError;
5294 SourceLocation ErrorLoc, NoteLoc;
5295 SourceRange ErrorRange, NoteRange;
5296 // Allowed constructs are:
5302 // x = x binop expr;
5303 // x = expr binop x;
5304 if (auto *AtomicBody = dyn_cast<Expr>(S)) {
5305 AtomicBody = AtomicBody->IgnoreParenImpCasts();
5306 if (AtomicBody->getType()->isScalarType() ||
5307 AtomicBody->isInstantiationDependent()) {
5308 if (auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>(
5309 AtomicBody->IgnoreParenImpCasts())) {
5310 // Check for Compound Assignment Operation
5311 Op = BinaryOperator::getOpForCompoundAssignment(
5312 AtomicCompAssignOp->getOpcode());
5313 OpLoc = AtomicCompAssignOp->getOperatorLoc();
5314 E = AtomicCompAssignOp->getRHS();
5315 X = AtomicCompAssignOp->getLHS()->IgnoreParens();
5316 IsXLHSInRHSPart = true;
5317 } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>(
5318 AtomicBody->IgnoreParenImpCasts())) {
5319 // Check for Binary Operation
5320 if (checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
5322 } else if (auto *AtomicUnaryOp = dyn_cast<UnaryOperator>(
5323 AtomicBody->IgnoreParenImpCasts())) {
5324 // Check for Unary Operation
5325 if (AtomicUnaryOp->isIncrementDecrementOp()) {
5326 IsPostfixUpdate = AtomicUnaryOp->isPostfix();
5327 Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub;
5328 OpLoc = AtomicUnaryOp->getOperatorLoc();
5329 X = AtomicUnaryOp->getSubExpr()->IgnoreParens();
5330 E = SemaRef.ActOnIntegerConstant(OpLoc, /*uint64_t Val=*/1).get();
5331 IsXLHSInRHSPart = true;
5333 ErrorFound = NotAnUnaryIncDecExpression;
5334 ErrorLoc = AtomicUnaryOp->getExprLoc();
5335 ErrorRange = AtomicUnaryOp->getSourceRange();
5336 NoteLoc = AtomicUnaryOp->getOperatorLoc();
5337 NoteRange = SourceRange(NoteLoc, NoteLoc);
5339 } else if (!AtomicBody->isInstantiationDependent()) {
5340 ErrorFound = NotABinaryOrUnaryExpression;
5341 NoteLoc = ErrorLoc = AtomicBody->getExprLoc();
5342 NoteRange = ErrorRange = AtomicBody->getSourceRange();
5345 ErrorFound = NotAScalarType;
5346 NoteLoc = ErrorLoc = AtomicBody->getLocStart();
5347 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5350 ErrorFound = NotAnExpression;
5351 NoteLoc = ErrorLoc = S->getLocStart();
5352 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5354 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
5355 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
5356 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
5358 } else if (SemaRef.CurContext->isDependentContext())
5359 E = X = UpdateExpr = nullptr;
5360 if (ErrorFound == NoError && E && X) {
5361 // Build an update expression of form 'OpaqueValueExpr(x) binop
5362 // OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop
5363 // OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression.
5364 auto *OVEX = new (SemaRef.getASTContext())
5365 OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue);
5366 auto *OVEExpr = new (SemaRef.getASTContext())
5367 OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue);
5369 SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr,
5370 IsXLHSInRHSPart ? OVEExpr : OVEX);
5371 if (Update.isInvalid())
5373 Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(),
5375 if (Update.isInvalid())
5377 UpdateExpr = Update.get();
5379 return ErrorFound != NoError;
5382 StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
5384 SourceLocation StartLoc,
5385 SourceLocation EndLoc) {
5389 auto *CS = cast<CapturedStmt>(AStmt);
5390 // 1.2.2 OpenMP Language Terminology
5391 // Structured block - An executable statement with a single entry at the
5392 // top and a single exit at the bottom.
5393 // The point of exit cannot be a branch out of the structured block.
5394 // longjmp() and throw() must not violate the entry/exit criteria.
5395 OpenMPClauseKind AtomicKind = OMPC_unknown;
5396 SourceLocation AtomicKindLoc;
5397 for (auto *C : Clauses) {
5398 if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write ||
5399 C->getClauseKind() == OMPC_update ||
5400 C->getClauseKind() == OMPC_capture) {
5401 if (AtomicKind != OMPC_unknown) {
5402 Diag(C->getLocStart(), diag::err_omp_atomic_several_clauses)
5403 << SourceRange(C->getLocStart(), C->getLocEnd());
5404 Diag(AtomicKindLoc, diag::note_omp_atomic_previous_clause)
5405 << getOpenMPClauseName(AtomicKind);
5407 AtomicKind = C->getClauseKind();
5408 AtomicKindLoc = C->getLocStart();
5413 auto Body = CS->getCapturedStmt();
5414 if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
5415 Body = EWC->getSubExpr();
5421 bool IsXLHSInRHSPart = false;
5422 bool IsPostfixUpdate = false;
5423 // OpenMP [2.12.6, atomic Construct]
5424 // In the next expressions:
5425 // * x and v (as applicable) are both l-value expressions with scalar type.
5426 // * During the execution of an atomic region, multiple syntactic
5427 // occurrences of x must designate the same storage location.
5428 // * Neither of v and expr (as applicable) may access the storage location
5430 // * Neither of x and expr (as applicable) may access the storage location
5432 // * expr is an expression with scalar type.
5433 // * binop is one of +, *, -, /, &, ^, |, <<, or >>.
5434 // * binop, binop=, ++, and -- are not overloaded operators.
5435 // * The expression x binop expr must be numerically equivalent to x binop
5436 // (expr). This requirement is satisfied if the operators in expr have
5437 // precedence greater than binop, or by using parentheses around expr or
5438 // subexpressions of expr.
5439 // * The expression expr binop x must be numerically equivalent to (expr)
5440 // binop x. This requirement is satisfied if the operators in expr have
5441 // precedence equal to or greater than binop, or by using parentheses around
5442 // expr or subexpressions of expr.
5443 // * For forms that allow multiple occurrences of x, the number of times
5444 // that x is evaluated is unspecified.
5445 if (AtomicKind == OMPC_read) {
5452 } ErrorFound = NoError;
5453 SourceLocation ErrorLoc, NoteLoc;
5454 SourceRange ErrorRange, NoteRange;
5455 // If clause is read:
5457 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5459 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5460 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5461 X = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
5462 V = AtomicBinOp->getLHS()->IgnoreParenImpCasts();
5463 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
5464 (V->isInstantiationDependent() || V->getType()->isScalarType())) {
5465 if (!X->isLValue() || !V->isLValue()) {
5466 auto NotLValueExpr = X->isLValue() ? V : X;
5467 ErrorFound = NotAnLValue;
5468 ErrorLoc = AtomicBinOp->getExprLoc();
5469 ErrorRange = AtomicBinOp->getSourceRange();
5470 NoteLoc = NotLValueExpr->getExprLoc();
5471 NoteRange = NotLValueExpr->getSourceRange();
5473 } else if (!X->isInstantiationDependent() ||
5474 !V->isInstantiationDependent()) {
5475 auto NotScalarExpr =
5476 (X->isInstantiationDependent() || X->getType()->isScalarType())
5479 ErrorFound = NotAScalarType;
5480 ErrorLoc = AtomicBinOp->getExprLoc();
5481 ErrorRange = AtomicBinOp->getSourceRange();
5482 NoteLoc = NotScalarExpr->getExprLoc();
5483 NoteRange = NotScalarExpr->getSourceRange();
5485 } else if (!AtomicBody->isInstantiationDependent()) {
5486 ErrorFound = NotAnAssignmentOp;
5487 ErrorLoc = AtomicBody->getExprLoc();
5488 ErrorRange = AtomicBody->getSourceRange();
5489 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5490 : AtomicBody->getExprLoc();
5491 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5492 : AtomicBody->getSourceRange();
5495 ErrorFound = NotAnExpression;
5496 NoteLoc = ErrorLoc = Body->getLocStart();
5497 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5499 if (ErrorFound != NoError) {
5500 Diag(ErrorLoc, diag::err_omp_atomic_read_not_expression_statement)
5502 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
5505 } else if (CurContext->isDependentContext())
5507 } else if (AtomicKind == OMPC_write) {
5514 } ErrorFound = NoError;
5515 SourceLocation ErrorLoc, NoteLoc;
5516 SourceRange ErrorRange, NoteRange;
5517 // If clause is write:
5519 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5521 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5522 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5523 X = AtomicBinOp->getLHS();
5524 E = AtomicBinOp->getRHS();
5525 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
5526 (E->isInstantiationDependent() || E->getType()->isScalarType())) {
5527 if (!X->isLValue()) {
5528 ErrorFound = NotAnLValue;
5529 ErrorLoc = AtomicBinOp->getExprLoc();
5530 ErrorRange = AtomicBinOp->getSourceRange();
5531 NoteLoc = X->getExprLoc();
5532 NoteRange = X->getSourceRange();
5534 } else if (!X->isInstantiationDependent() ||
5535 !E->isInstantiationDependent()) {
5536 auto NotScalarExpr =
5537 (X->isInstantiationDependent() || X->getType()->isScalarType())
5540 ErrorFound = NotAScalarType;
5541 ErrorLoc = AtomicBinOp->getExprLoc();
5542 ErrorRange = AtomicBinOp->getSourceRange();
5543 NoteLoc = NotScalarExpr->getExprLoc();
5544 NoteRange = NotScalarExpr->getSourceRange();
5546 } else if (!AtomicBody->isInstantiationDependent()) {
5547 ErrorFound = NotAnAssignmentOp;
5548 ErrorLoc = AtomicBody->getExprLoc();
5549 ErrorRange = AtomicBody->getSourceRange();
5550 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5551 : AtomicBody->getExprLoc();
5552 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5553 : AtomicBody->getSourceRange();
5556 ErrorFound = NotAnExpression;
5557 NoteLoc = ErrorLoc = Body->getLocStart();
5558 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5560 if (ErrorFound != NoError) {
5561 Diag(ErrorLoc, diag::err_omp_atomic_write_not_expression_statement)
5563 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
5566 } else if (CurContext->isDependentContext())
5568 } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {
5569 // If clause is update:
5575 // x = x binop expr;
5576 // x = expr binop x;
5577 OpenMPAtomicUpdateChecker Checker(*this);
5578 if (Checker.checkStatement(
5579 Body, (AtomicKind == OMPC_update)
5580 ? diag::err_omp_atomic_update_not_expression_statement
5581 : diag::err_omp_atomic_not_expression_statement,
5582 diag::note_omp_atomic_update))
5584 if (!CurContext->isDependentContext()) {
5585 E = Checker.getExpr();
5587 UE = Checker.getUpdateExpr();
5588 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5590 } else if (AtomicKind == OMPC_capture) {
5593 NotACompoundStatement,
5594 NotTwoSubstatements,
5595 NotASpecificExpression,
5597 } ErrorFound = NoError;
5598 SourceLocation ErrorLoc, NoteLoc;
5599 SourceRange ErrorRange, NoteRange;
5600 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5601 // If clause is a capture:
5606 // v = x binop= expr;
5607 // v = x = x binop expr;
5608 // v = x = expr binop x;
5610 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5611 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5612 V = AtomicBinOp->getLHS();
5613 Body = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
5614 OpenMPAtomicUpdateChecker Checker(*this);
5615 if (Checker.checkStatement(
5616 Body, diag::err_omp_atomic_capture_not_expression_statement,
5617 diag::note_omp_atomic_update))
5619 E = Checker.getExpr();
5621 UE = Checker.getUpdateExpr();
5622 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5623 IsPostfixUpdate = Checker.isPostfixUpdate();
5624 } else if (!AtomicBody->isInstantiationDependent()) {
5625 ErrorLoc = AtomicBody->getExprLoc();
5626 ErrorRange = AtomicBody->getSourceRange();
5627 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5628 : AtomicBody->getExprLoc();
5629 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5630 : AtomicBody->getSourceRange();
5631 ErrorFound = NotAnAssignmentOp;
5633 if (ErrorFound != NoError) {
5634 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_expression_statement)
5636 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
5638 } else if (CurContext->isDependentContext()) {
5639 UE = V = E = X = nullptr;
5642 // If clause is a capture:
5643 // { v = x; x = expr; }
5648 // { v = x; x binop= expr; }
5649 // { v = x; x = x binop expr; }
5650 // { v = x; x = expr binop x; }
5655 // { x binop= expr; v = x; }
5656 // { x = x binop expr; v = x; }
5657 // { x = expr binop x; v = x; }
5658 if (auto *CS = dyn_cast<CompoundStmt>(Body)) {
5659 // Check that this is { expr1; expr2; }
5660 if (CS->size() == 2) {
5661 auto *First = CS->body_front();
5662 auto *Second = CS->body_back();
5663 if (auto *EWC = dyn_cast<ExprWithCleanups>(First))
5664 First = EWC->getSubExpr()->IgnoreParenImpCasts();
5665 if (auto *EWC = dyn_cast<ExprWithCleanups>(Second))
5666 Second = EWC->getSubExpr()->IgnoreParenImpCasts();
5667 // Need to find what subexpression is 'v' and what is 'x'.
5668 OpenMPAtomicUpdateChecker Checker(*this);
5669 bool IsUpdateExprFound = !Checker.checkStatement(Second);
5670 BinaryOperator *BinOp = nullptr;
5671 if (IsUpdateExprFound) {
5672 BinOp = dyn_cast<BinaryOperator>(First);
5673 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
5675 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
5680 // { v = x; x binop= expr; }
5681 // { v = x; x = x binop expr; }
5682 // { v = x; x = expr binop x; }
5683 // Check that the first expression has form v = x.
5684 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
5685 llvm::FoldingSetNodeID XId, PossibleXId;
5686 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
5687 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
5688 IsUpdateExprFound = XId == PossibleXId;
5689 if (IsUpdateExprFound) {
5690 V = BinOp->getLHS();
5692 E = Checker.getExpr();
5693 UE = Checker.getUpdateExpr();
5694 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5695 IsPostfixUpdate = true;
5698 if (!IsUpdateExprFound) {
5699 IsUpdateExprFound = !Checker.checkStatement(First);
5701 if (IsUpdateExprFound) {
5702 BinOp = dyn_cast<BinaryOperator>(Second);
5703 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
5705 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
5710 // { x binop= expr; v = x; }
5711 // { x = x binop expr; v = x; }
5712 // { x = expr binop x; v = x; }
5713 // Check that the second expression has form v = x.
5714 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
5715 llvm::FoldingSetNodeID XId, PossibleXId;
5716 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
5717 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
5718 IsUpdateExprFound = XId == PossibleXId;
5719 if (IsUpdateExprFound) {
5720 V = BinOp->getLHS();
5722 E = Checker.getExpr();
5723 UE = Checker.getUpdateExpr();
5724 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5725 IsPostfixUpdate = false;
5729 if (!IsUpdateExprFound) {
5730 // { v = x; x = expr; }
5731 auto *FirstExpr = dyn_cast<Expr>(First);
5732 auto *SecondExpr = dyn_cast<Expr>(Second);
5733 if (!FirstExpr || !SecondExpr ||
5734 !(FirstExpr->isInstantiationDependent() ||
5735 SecondExpr->isInstantiationDependent())) {
5736 auto *FirstBinOp = dyn_cast<BinaryOperator>(First);
5737 if (!FirstBinOp || FirstBinOp->getOpcode() != BO_Assign) {
5738 ErrorFound = NotAnAssignmentOp;
5739 NoteLoc = ErrorLoc = FirstBinOp ? FirstBinOp->getOperatorLoc()
5740 : First->getLocStart();
5741 NoteRange = ErrorRange = FirstBinOp
5742 ? FirstBinOp->getSourceRange()
5743 : SourceRange(ErrorLoc, ErrorLoc);
5745 auto *SecondBinOp = dyn_cast<BinaryOperator>(Second);
5746 if (!SecondBinOp || SecondBinOp->getOpcode() != BO_Assign) {
5747 ErrorFound = NotAnAssignmentOp;
5748 NoteLoc = ErrorLoc = SecondBinOp
5749 ? SecondBinOp->getOperatorLoc()
5750 : Second->getLocStart();
5751 NoteRange = ErrorRange =
5752 SecondBinOp ? SecondBinOp->getSourceRange()
5753 : SourceRange(ErrorLoc, ErrorLoc);
5755 auto *PossibleXRHSInFirst =
5756 FirstBinOp->getRHS()->IgnoreParenImpCasts();
5757 auto *PossibleXLHSInSecond =
5758 SecondBinOp->getLHS()->IgnoreParenImpCasts();
5759 llvm::FoldingSetNodeID X1Id, X2Id;
5760 PossibleXRHSInFirst->Profile(X1Id, Context,
5761 /*Canonical=*/true);
5762 PossibleXLHSInSecond->Profile(X2Id, Context,
5763 /*Canonical=*/true);
5764 IsUpdateExprFound = X1Id == X2Id;
5765 if (IsUpdateExprFound) {
5766 V = FirstBinOp->getLHS();
5767 X = SecondBinOp->getLHS();
5768 E = SecondBinOp->getRHS();
5770 IsXLHSInRHSPart = false;
5771 IsPostfixUpdate = true;
5773 ErrorFound = NotASpecificExpression;
5774 ErrorLoc = FirstBinOp->getExprLoc();
5775 ErrorRange = FirstBinOp->getSourceRange();
5776 NoteLoc = SecondBinOp->getLHS()->getExprLoc();
5777 NoteRange = SecondBinOp->getRHS()->getSourceRange();
5784 NoteLoc = ErrorLoc = Body->getLocStart();
5785 NoteRange = ErrorRange =
5786 SourceRange(Body->getLocStart(), Body->getLocStart());
5787 ErrorFound = NotTwoSubstatements;
5790 NoteLoc = ErrorLoc = Body->getLocStart();
5791 NoteRange = ErrorRange =
5792 SourceRange(Body->getLocStart(), Body->getLocStart());
5793 ErrorFound = NotACompoundStatement;
5795 if (ErrorFound != NoError) {
5796 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement)
5798 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
5800 } else if (CurContext->isDependentContext()) {
5801 UE = V = E = X = nullptr;
5806 getCurFunction()->setHasBranchProtectedScope();
5808 return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5809 X, V, E, UE, IsXLHSInRHSPart,
5813 StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
5815 SourceLocation StartLoc,
5816 SourceLocation EndLoc) {
5820 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5821 // 1.2.2 OpenMP Language Terminology
5822 // Structured block - An executable statement with a single entry at the
5823 // top and a single exit at the bottom.
5824 // The point of exit cannot be a branch out of the structured block.
5825 // longjmp() and throw() must not violate the entry/exit criteria.
5826 CS->getCapturedDecl()->setNothrow();
5828 // OpenMP [2.16, Nesting of Regions]
5829 // If specified, a teams construct must be contained within a target
5830 // construct. That target construct must contain no statements or directives
5831 // outside of the teams construct.
5832 if (DSAStack->hasInnerTeamsRegion()) {
5833 auto S = AStmt->IgnoreContainers(/*IgnoreCaptured*/ true);
5834 bool OMPTeamsFound = true;
5835 if (auto *CS = dyn_cast<CompoundStmt>(S)) {
5836 auto I = CS->body_begin();
5837 while (I != CS->body_end()) {
5838 auto *OED = dyn_cast<OMPExecutableDirective>(*I);
5839 if (!OED || !isOpenMPTeamsDirective(OED->getDirectiveKind())) {
5840 OMPTeamsFound = false;
5845 assert(I != CS->body_end() && "Not found statement");
5848 auto *OED = dyn_cast<OMPExecutableDirective>(S);
5849 OMPTeamsFound = OED && isOpenMPTeamsDirective(OED->getDirectiveKind());
5851 if (!OMPTeamsFound) {
5852 Diag(StartLoc, diag::err_omp_target_contains_not_only_teams);
5853 Diag(DSAStack->getInnerTeamsRegionLoc(),
5854 diag::note_omp_nested_teams_construct_here);
5855 Diag(S->getLocStart(), diag::note_omp_nested_statement_here)
5856 << isa<OMPExecutableDirective>(S);
5861 getCurFunction()->setHasBranchProtectedScope();
5863 return OMPTargetDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5867 Sema::ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
5868 Stmt *AStmt, SourceLocation StartLoc,
5869 SourceLocation EndLoc) {
5873 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5874 // 1.2.2 OpenMP Language Terminology
5875 // Structured block - An executable statement with a single entry at the
5876 // top and a single exit at the bottom.
5877 // The point of exit cannot be a branch out of the structured block.
5878 // longjmp() and throw() must not violate the entry/exit criteria.
5879 CS->getCapturedDecl()->setNothrow();
5881 getCurFunction()->setHasBranchProtectedScope();
5883 return OMPTargetParallelDirective::Create(Context, StartLoc, EndLoc, Clauses,
5887 StmtResult Sema::ActOnOpenMPTargetParallelForDirective(
5888 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5889 SourceLocation EndLoc,
5890 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5894 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5895 // 1.2.2 OpenMP Language Terminology
5896 // Structured block - An executable statement with a single entry at the
5897 // top and a single exit at the bottom.
5898 // The point of exit cannot be a branch out of the structured block.
5899 // longjmp() and throw() must not violate the entry/exit criteria.
5900 CS->getCapturedDecl()->setNothrow();
5902 OMPLoopDirective::HelperExprs B;
5903 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5904 // define the nested loops number.
5905 unsigned NestedLoopCount =
5906 CheckOpenMPLoop(OMPD_target_parallel_for, getCollapseNumberExpr(Clauses),
5907 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
5908 VarsWithImplicitDSA, B);
5909 if (NestedLoopCount == 0)
5912 assert((CurContext->isDependentContext() || B.builtAll()) &&
5913 "omp target parallel for loop exprs were not built");
5915 if (!CurContext->isDependentContext()) {
5916 // Finalize the clauses that need pre-built expressions for CodeGen.
5917 for (auto C : Clauses) {
5918 if (auto *LC = dyn_cast<OMPLinearClause>(C))
5919 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5920 B.NumIterations, *this, CurScope,
5926 getCurFunction()->setHasBranchProtectedScope();
5927 return OMPTargetParallelForDirective::Create(Context, StartLoc, EndLoc,
5928 NestedLoopCount, Clauses, AStmt,
5929 B, DSAStack->isCancelRegion());
5932 /// Check for existence of a map clause in the list of clauses.
5933 static bool hasClauses(ArrayRef<OMPClause *> Clauses,
5934 const OpenMPClauseKind K) {
5935 return llvm::any_of(
5936 Clauses, [K](const OMPClause *C) { return C->getClauseKind() == K; });
5939 template <typename... Params>
5940 static bool hasClauses(ArrayRef<OMPClause *> Clauses, const OpenMPClauseKind K,
5941 const Params... ClauseTypes) {
5942 return hasClauses(Clauses, K) || hasClauses(Clauses, ClauseTypes...);
5945 StmtResult Sema::ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
5947 SourceLocation StartLoc,
5948 SourceLocation EndLoc) {
5952 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
5954 // OpenMP [2.10.1, Restrictions, p. 97]
5955 // At least one map clause must appear on the directive.
5956 if (!hasClauses(Clauses, OMPC_map, OMPC_use_device_ptr)) {
5957 Diag(StartLoc, diag::err_omp_no_clause_for_directive)
5958 << "'map' or 'use_device_ptr'"
5959 << getOpenMPDirectiveName(OMPD_target_data);
5963 getCurFunction()->setHasBranchProtectedScope();
5965 return OMPTargetDataDirective::Create(Context, StartLoc, EndLoc, Clauses,
5970 Sema::ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
5971 SourceLocation StartLoc,
5972 SourceLocation EndLoc) {
5973 // OpenMP [2.10.2, Restrictions, p. 99]
5974 // At least one map clause must appear on the directive.
5975 if (!hasClauses(Clauses, OMPC_map)) {
5976 Diag(StartLoc, diag::err_omp_no_clause_for_directive)
5977 << "'map'" << getOpenMPDirectiveName(OMPD_target_enter_data);
5981 return OMPTargetEnterDataDirective::Create(Context, StartLoc, EndLoc,
5986 Sema::ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
5987 SourceLocation StartLoc,
5988 SourceLocation EndLoc) {
5989 // OpenMP [2.10.3, Restrictions, p. 102]
5990 // At least one map clause must appear on the directive.
5991 if (!hasClauses(Clauses, OMPC_map)) {
5992 Diag(StartLoc, diag::err_omp_no_clause_for_directive)
5993 << "'map'" << getOpenMPDirectiveName(OMPD_target_exit_data);
5997 return OMPTargetExitDataDirective::Create(Context, StartLoc, EndLoc, Clauses);
6000 StmtResult Sema::ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
6001 SourceLocation StartLoc,
6002 SourceLocation EndLoc) {
6003 if (!hasClauses(Clauses, OMPC_to, OMPC_from)) {
6004 Diag(StartLoc, diag::err_omp_at_least_one_motion_clause_required);
6007 return OMPTargetUpdateDirective::Create(Context, StartLoc, EndLoc, Clauses);
6010 StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
6011 Stmt *AStmt, SourceLocation StartLoc,
6012 SourceLocation EndLoc) {
6016 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6017 // 1.2.2 OpenMP Language Terminology
6018 // Structured block - An executable statement with a single entry at the
6019 // top and a single exit at the bottom.
6020 // The point of exit cannot be a branch out of the structured block.
6021 // longjmp() and throw() must not violate the entry/exit criteria.
6022 CS->getCapturedDecl()->setNothrow();
6024 getCurFunction()->setHasBranchProtectedScope();
6026 return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
6030 Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
6031 SourceLocation EndLoc,
6032 OpenMPDirectiveKind CancelRegion) {
6033 if (DSAStack->isParentNowaitRegion()) {
6034 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0;
6037 if (DSAStack->isParentOrderedRegion()) {
6038 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0;
6041 return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc,
6045 StmtResult Sema::ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
6046 SourceLocation StartLoc,
6047 SourceLocation EndLoc,
6048 OpenMPDirectiveKind CancelRegion) {
6049 if (DSAStack->isParentNowaitRegion()) {
6050 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1;
6053 if (DSAStack->isParentOrderedRegion()) {
6054 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1;
6057 DSAStack->setParentCancelRegion(/*Cancel=*/true);
6058 return OMPCancelDirective::Create(Context, StartLoc, EndLoc, Clauses,
6062 static bool checkGrainsizeNumTasksClauses(Sema &S,
6063 ArrayRef<OMPClause *> Clauses) {
6064 OMPClause *PrevClause = nullptr;
6065 bool ErrorFound = false;
6066 for (auto *C : Clauses) {
6067 if (C->getClauseKind() == OMPC_grainsize ||
6068 C->getClauseKind() == OMPC_num_tasks) {
6071 else if (PrevClause->getClauseKind() != C->getClauseKind()) {
6072 S.Diag(C->getLocStart(),
6073 diag::err_omp_grainsize_num_tasks_mutually_exclusive)
6074 << getOpenMPClauseName(C->getClauseKind())
6075 << getOpenMPClauseName(PrevClause->getClauseKind());
6076 S.Diag(PrevClause->getLocStart(),
6077 diag::note_omp_previous_grainsize_num_tasks)
6078 << getOpenMPClauseName(PrevClause->getClauseKind());
6086 StmtResult Sema::ActOnOpenMPTaskLoopDirective(
6087 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6088 SourceLocation EndLoc,
6089 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6093 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6094 OMPLoopDirective::HelperExprs B;
6095 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6096 // define the nested loops number.
6097 unsigned NestedLoopCount =
6098 CheckOpenMPLoop(OMPD_taskloop, getCollapseNumberExpr(Clauses),
6099 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
6100 VarsWithImplicitDSA, B);
6101 if (NestedLoopCount == 0)
6104 assert((CurContext->isDependentContext() || B.builtAll()) &&
6105 "omp for loop exprs were not built");
6107 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
6108 // The grainsize clause and num_tasks clause are mutually exclusive and may
6109 // not appear on the same taskloop directive.
6110 if (checkGrainsizeNumTasksClauses(*this, Clauses))
6113 getCurFunction()->setHasBranchProtectedScope();
6114 return OMPTaskLoopDirective::Create(Context, StartLoc, EndLoc,
6115 NestedLoopCount, Clauses, AStmt, B);
6118 StmtResult Sema::ActOnOpenMPTaskLoopSimdDirective(
6119 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6120 SourceLocation EndLoc,
6121 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6125 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6126 OMPLoopDirective::HelperExprs B;
6127 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6128 // define the nested loops number.
6129 unsigned NestedLoopCount =
6130 CheckOpenMPLoop(OMPD_taskloop_simd, getCollapseNumberExpr(Clauses),
6131 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
6132 VarsWithImplicitDSA, B);
6133 if (NestedLoopCount == 0)
6136 assert((CurContext->isDependentContext() || B.builtAll()) &&
6137 "omp for loop exprs were not built");
6139 if (!CurContext->isDependentContext()) {
6140 // Finalize the clauses that need pre-built expressions for CodeGen.
6141 for (auto C : Clauses) {
6142 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6143 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6144 B.NumIterations, *this, CurScope,
6150 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
6151 // The grainsize clause and num_tasks clause are mutually exclusive and may
6152 // not appear on the same taskloop directive.
6153 if (checkGrainsizeNumTasksClauses(*this, Clauses))
6156 getCurFunction()->setHasBranchProtectedScope();
6157 return OMPTaskLoopSimdDirective::Create(Context, StartLoc, EndLoc,
6158 NestedLoopCount, Clauses, AStmt, B);
6161 StmtResult Sema::ActOnOpenMPDistributeDirective(
6162 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6163 SourceLocation EndLoc,
6164 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6168 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
6169 OMPLoopDirective::HelperExprs B;
6170 // In presence of clause 'collapse' with number of loops, it will
6171 // define the nested loops number.
6172 unsigned NestedLoopCount =
6173 CheckOpenMPLoop(OMPD_distribute, getCollapseNumberExpr(Clauses),
6174 nullptr /*ordered not a clause on distribute*/, AStmt,
6175 *this, *DSAStack, VarsWithImplicitDSA, B);
6176 if (NestedLoopCount == 0)
6179 assert((CurContext->isDependentContext() || B.builtAll()) &&
6180 "omp for loop exprs were not built");
6182 getCurFunction()->setHasBranchProtectedScope();
6183 return OMPDistributeDirective::Create(Context, StartLoc, EndLoc,
6184 NestedLoopCount, Clauses, AStmt, B);
6187 StmtResult Sema::ActOnOpenMPDistributeParallelForDirective(
6188 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6189 SourceLocation EndLoc,
6190 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6194 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6195 // 1.2.2 OpenMP Language Terminology
6196 // Structured block - An executable statement with a single entry at the
6197 // top and a single exit at the bottom.
6198 // The point of exit cannot be a branch out of the structured block.
6199 // longjmp() and throw() must not violate the entry/exit criteria.
6200 CS->getCapturedDecl()->setNothrow();
6202 OMPLoopDirective::HelperExprs B;
6203 // In presence of clause 'collapse' with number of loops, it will
6204 // define the nested loops number.
6205 unsigned NestedLoopCount = CheckOpenMPLoop(
6206 OMPD_distribute_parallel_for, getCollapseNumberExpr(Clauses),
6207 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6208 VarsWithImplicitDSA, B);
6209 if (NestedLoopCount == 0)
6212 assert((CurContext->isDependentContext() || B.builtAll()) &&
6213 "omp for loop exprs were not built");
6215 getCurFunction()->setHasBranchProtectedScope();
6216 return OMPDistributeParallelForDirective::Create(
6217 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6220 StmtResult Sema::ActOnOpenMPDistributeParallelForSimdDirective(
6221 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6222 SourceLocation EndLoc,
6223 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6227 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6228 // 1.2.2 OpenMP Language Terminology
6229 // Structured block - An executable statement with a single entry at the
6230 // top and a single exit at the bottom.
6231 // The point of exit cannot be a branch out of the structured block.
6232 // longjmp() and throw() must not violate the entry/exit criteria.
6233 CS->getCapturedDecl()->setNothrow();
6235 OMPLoopDirective::HelperExprs B;
6236 // In presence of clause 'collapse' with number of loops, it will
6237 // define the nested loops number.
6238 unsigned NestedLoopCount = CheckOpenMPLoop(
6239 OMPD_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
6240 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6241 VarsWithImplicitDSA, B);
6242 if (NestedLoopCount == 0)
6245 assert((CurContext->isDependentContext() || B.builtAll()) &&
6246 "omp for loop exprs were not built");
6248 if (checkSimdlenSafelenSpecified(*this, Clauses))
6251 getCurFunction()->setHasBranchProtectedScope();
6252 return OMPDistributeParallelForSimdDirective::Create(
6253 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6256 StmtResult Sema::ActOnOpenMPDistributeSimdDirective(
6257 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6258 SourceLocation EndLoc,
6259 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6263 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6264 // 1.2.2 OpenMP Language Terminology
6265 // Structured block - An executable statement with a single entry at the
6266 // top and a single exit at the bottom.
6267 // The point of exit cannot be a branch out of the structured block.
6268 // longjmp() and throw() must not violate the entry/exit criteria.
6269 CS->getCapturedDecl()->setNothrow();
6271 OMPLoopDirective::HelperExprs B;
6272 // In presence of clause 'collapse' with number of loops, it will
6273 // define the nested loops number.
6274 unsigned NestedLoopCount =
6275 CheckOpenMPLoop(OMPD_distribute_simd, getCollapseNumberExpr(Clauses),
6276 nullptr /*ordered not a clause on distribute*/, AStmt,
6277 *this, *DSAStack, VarsWithImplicitDSA, B);
6278 if (NestedLoopCount == 0)
6281 assert((CurContext->isDependentContext() || B.builtAll()) &&
6282 "omp for loop exprs were not built");
6284 if (checkSimdlenSafelenSpecified(*this, Clauses))
6287 getCurFunction()->setHasBranchProtectedScope();
6288 return OMPDistributeSimdDirective::Create(Context, StartLoc, EndLoc,
6289 NestedLoopCount, Clauses, AStmt, B);
6292 StmtResult Sema::ActOnOpenMPTargetParallelForSimdDirective(
6293 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6294 SourceLocation EndLoc,
6295 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6299 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6300 // 1.2.2 OpenMP Language Terminology
6301 // Structured block - An executable statement with a single entry at the
6302 // top and a single exit at the bottom.
6303 // The point of exit cannot be a branch out of the structured block.
6304 // longjmp() and throw() must not violate the entry/exit criteria.
6305 CS->getCapturedDecl()->setNothrow();
6307 OMPLoopDirective::HelperExprs B;
6308 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6309 // define the nested loops number.
6310 unsigned NestedLoopCount = CheckOpenMPLoop(
6311 OMPD_target_parallel_for_simd, getCollapseNumberExpr(Clauses),
6312 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
6313 VarsWithImplicitDSA, B);
6314 if (NestedLoopCount == 0)
6317 assert((CurContext->isDependentContext() || B.builtAll()) &&
6318 "omp target parallel for simd loop exprs were not built");
6320 if (!CurContext->isDependentContext()) {
6321 // Finalize the clauses that need pre-built expressions for CodeGen.
6322 for (auto C : Clauses) {
6323 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6324 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6325 B.NumIterations, *this, CurScope,
6330 if (checkSimdlenSafelenSpecified(*this, Clauses))
6333 getCurFunction()->setHasBranchProtectedScope();
6334 return OMPTargetParallelForSimdDirective::Create(
6335 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6338 StmtResult Sema::ActOnOpenMPTargetSimdDirective(
6339 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6340 SourceLocation EndLoc,
6341 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6345 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6346 // 1.2.2 OpenMP Language Terminology
6347 // Structured block - An executable statement with a single entry at the
6348 // top and a single exit at the bottom.
6349 // The point of exit cannot be a branch out of the structured block.
6350 // longjmp() and throw() must not violate the entry/exit criteria.
6351 CS->getCapturedDecl()->setNothrow();
6353 OMPLoopDirective::HelperExprs B;
6354 // In presence of clause 'collapse' with number of loops, it will define the
6355 // nested loops number.
6356 unsigned NestedLoopCount =
6357 CheckOpenMPLoop(OMPD_target_simd, getCollapseNumberExpr(Clauses),
6358 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack,
6359 VarsWithImplicitDSA, B);
6360 if (NestedLoopCount == 0)
6363 assert((CurContext->isDependentContext() || B.builtAll()) &&
6364 "omp target simd loop exprs were not built");
6366 if (!CurContext->isDependentContext()) {
6367 // Finalize the clauses that need pre-built expressions for CodeGen.
6368 for (auto C : Clauses) {
6369 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6370 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6371 B.NumIterations, *this, CurScope,
6377 if (checkSimdlenSafelenSpecified(*this, Clauses))
6380 getCurFunction()->setHasBranchProtectedScope();
6381 return OMPTargetSimdDirective::Create(Context, StartLoc, EndLoc,
6382 NestedLoopCount, Clauses, AStmt, B);
6385 StmtResult Sema::ActOnOpenMPTeamsDistributeDirective(
6386 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6387 SourceLocation EndLoc,
6388 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6392 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6393 // 1.2.2 OpenMP Language Terminology
6394 // Structured block - An executable statement with a single entry at the
6395 // top and a single exit at the bottom.
6396 // The point of exit cannot be a branch out of the structured block.
6397 // longjmp() and throw() must not violate the entry/exit criteria.
6398 CS->getCapturedDecl()->setNothrow();
6400 OMPLoopDirective::HelperExprs B;
6401 // In presence of clause 'collapse' with number of loops, it will
6402 // define the nested loops number.
6403 unsigned NestedLoopCount =
6404 CheckOpenMPLoop(OMPD_teams_distribute, getCollapseNumberExpr(Clauses),
6405 nullptr /*ordered not a clause on distribute*/, AStmt,
6406 *this, *DSAStack, VarsWithImplicitDSA, B);
6407 if (NestedLoopCount == 0)
6410 assert((CurContext->isDependentContext() || B.builtAll()) &&
6411 "omp teams distribute loop exprs were not built");
6413 getCurFunction()->setHasBranchProtectedScope();
6414 return OMPTeamsDistributeDirective::Create(
6415 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6418 StmtResult Sema::ActOnOpenMPTeamsDistributeSimdDirective(
6419 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6420 SourceLocation EndLoc,
6421 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6425 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6426 // 1.2.2 OpenMP Language Terminology
6427 // Structured block - An executable statement with a single entry at the
6428 // top and a single exit at the bottom.
6429 // The point of exit cannot be a branch out of the structured block.
6430 // longjmp() and throw() must not violate the entry/exit criteria.
6431 CS->getCapturedDecl()->setNothrow();
6433 OMPLoopDirective::HelperExprs B;
6434 // In presence of clause 'collapse' with number of loops, it will
6435 // define the nested loops number.
6436 unsigned NestedLoopCount = CheckOpenMPLoop(
6437 OMPD_teams_distribute_simd, getCollapseNumberExpr(Clauses),
6438 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6439 VarsWithImplicitDSA, B);
6441 if (NestedLoopCount == 0)
6444 assert((CurContext->isDependentContext() || B.builtAll()) &&
6445 "omp teams distribute simd loop exprs were not built");
6447 if (!CurContext->isDependentContext()) {
6448 // Finalize the clauses that need pre-built expressions for CodeGen.
6449 for (auto C : Clauses) {
6450 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6451 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6452 B.NumIterations, *this, CurScope,
6458 if (checkSimdlenSafelenSpecified(*this, Clauses))
6461 getCurFunction()->setHasBranchProtectedScope();
6462 return OMPTeamsDistributeSimdDirective::Create(
6463 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6466 StmtResult Sema::ActOnOpenMPTeamsDistributeParallelForSimdDirective(
6467 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6468 SourceLocation EndLoc,
6469 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6473 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6474 // 1.2.2 OpenMP Language Terminology
6475 // Structured block - An executable statement with a single entry at the
6476 // top and a single exit at the bottom.
6477 // The point of exit cannot be a branch out of the structured block.
6478 // longjmp() and throw() must not violate the entry/exit criteria.
6479 CS->getCapturedDecl()->setNothrow();
6481 OMPLoopDirective::HelperExprs B;
6482 // In presence of clause 'collapse' with number of loops, it will
6483 // define the nested loops number.
6484 auto NestedLoopCount = CheckOpenMPLoop(
6485 OMPD_teams_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
6486 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6487 VarsWithImplicitDSA, B);
6489 if (NestedLoopCount == 0)
6492 assert((CurContext->isDependentContext() || B.builtAll()) &&
6493 "omp for loop exprs were not built");
6495 if (!CurContext->isDependentContext()) {
6496 // Finalize the clauses that need pre-built expressions for CodeGen.
6497 for (auto C : Clauses) {
6498 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6499 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6500 B.NumIterations, *this, CurScope,
6506 if (checkSimdlenSafelenSpecified(*this, Clauses))
6509 getCurFunction()->setHasBranchProtectedScope();
6510 return OMPTeamsDistributeParallelForSimdDirective::Create(
6511 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6514 StmtResult Sema::ActOnOpenMPTeamsDistributeParallelForDirective(
6515 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6516 SourceLocation EndLoc,
6517 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6521 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6522 // 1.2.2 OpenMP Language Terminology
6523 // Structured block - An executable statement with a single entry at the
6524 // top and a single exit at the bottom.
6525 // The point of exit cannot be a branch out of the structured block.
6526 // longjmp() and throw() must not violate the entry/exit criteria.
6527 CS->getCapturedDecl()->setNothrow();
6529 OMPLoopDirective::HelperExprs B;
6530 // In presence of clause 'collapse' with number of loops, it will
6531 // define the nested loops number.
6532 unsigned NestedLoopCount = CheckOpenMPLoop(
6533 OMPD_teams_distribute_parallel_for, getCollapseNumberExpr(Clauses),
6534 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6535 VarsWithImplicitDSA, B);
6537 if (NestedLoopCount == 0)
6540 assert((CurContext->isDependentContext() || B.builtAll()) &&
6541 "omp for loop exprs were not built");
6543 if (!CurContext->isDependentContext()) {
6544 // Finalize the clauses that need pre-built expressions for CodeGen.
6545 for (auto C : Clauses) {
6546 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6547 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6548 B.NumIterations, *this, CurScope,
6554 getCurFunction()->setHasBranchProtectedScope();
6555 return OMPTeamsDistributeParallelForDirective::Create(
6556 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6559 StmtResult Sema::ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
6561 SourceLocation StartLoc,
6562 SourceLocation EndLoc) {
6566 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6567 // 1.2.2 OpenMP Language Terminology
6568 // Structured block - An executable statement with a single entry at the
6569 // top and a single exit at the bottom.
6570 // The point of exit cannot be a branch out of the structured block.
6571 // longjmp() and throw() must not violate the entry/exit criteria.
6572 CS->getCapturedDecl()->setNothrow();
6574 getCurFunction()->setHasBranchProtectedScope();
6576 return OMPTargetTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses,
6580 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeDirective(
6581 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6582 SourceLocation EndLoc,
6583 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6587 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6588 // 1.2.2 OpenMP Language Terminology
6589 // Structured block - An executable statement with a single entry at the
6590 // top and a single exit at the bottom.
6591 // The point of exit cannot be a branch out of the structured block.
6592 // longjmp() and throw() must not violate the entry/exit criteria.
6593 CS->getCapturedDecl()->setNothrow();
6595 OMPLoopDirective::HelperExprs B;
6596 // In presence of clause 'collapse' with number of loops, it will
6597 // define the nested loops number.
6598 auto NestedLoopCount = CheckOpenMPLoop(
6599 OMPD_target_teams_distribute,
6600 getCollapseNumberExpr(Clauses),
6601 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6602 VarsWithImplicitDSA, B);
6603 if (NestedLoopCount == 0)
6606 assert((CurContext->isDependentContext() || B.builtAll()) &&
6607 "omp target teams distribute loop exprs were not built");
6609 getCurFunction()->setHasBranchProtectedScope();
6610 return OMPTargetTeamsDistributeDirective::Create(
6611 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6614 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeParallelForDirective(
6615 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6616 SourceLocation EndLoc,
6617 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6621 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6622 // 1.2.2 OpenMP Language Terminology
6623 // Structured block - An executable statement with a single entry at the
6624 // top and a single exit at the bottom.
6625 // The point of exit cannot be a branch out of the structured block.
6626 // longjmp() and throw() must not violate the entry/exit criteria.
6627 CS->getCapturedDecl()->setNothrow();
6629 OMPLoopDirective::HelperExprs B;
6630 // In presence of clause 'collapse' with number of loops, it will
6631 // define the nested loops number.
6632 auto NestedLoopCount = CheckOpenMPLoop(
6633 OMPD_target_teams_distribute_parallel_for,
6634 getCollapseNumberExpr(Clauses),
6635 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6636 VarsWithImplicitDSA, B);
6637 if (NestedLoopCount == 0)
6640 assert((CurContext->isDependentContext() || B.builtAll()) &&
6641 "omp target teams distribute parallel for loop exprs were not built");
6643 if (!CurContext->isDependentContext()) {
6644 // Finalize the clauses that need pre-built expressions for CodeGen.
6645 for (auto C : Clauses) {
6646 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6647 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6648 B.NumIterations, *this, CurScope,
6654 getCurFunction()->setHasBranchProtectedScope();
6655 return OMPTargetTeamsDistributeParallelForDirective::Create(
6656 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6659 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
6660 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6661 SourceLocation EndLoc,
6662 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6666 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6667 // 1.2.2 OpenMP Language Terminology
6668 // Structured block - An executable statement with a single entry at the
6669 // top and a single exit at the bottom.
6670 // The point of exit cannot be a branch out of the structured block.
6671 // longjmp() and throw() must not violate the entry/exit criteria.
6672 CS->getCapturedDecl()->setNothrow();
6674 OMPLoopDirective::HelperExprs B;
6675 // In presence of clause 'collapse' with number of loops, it will
6676 // define the nested loops number.
6677 auto NestedLoopCount = CheckOpenMPLoop(
6678 OMPD_target_teams_distribute_parallel_for_simd,
6679 getCollapseNumberExpr(Clauses),
6680 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6681 VarsWithImplicitDSA, B);
6682 if (NestedLoopCount == 0)
6685 assert((CurContext->isDependentContext() || B.builtAll()) &&
6686 "omp target teams distribute parallel for simd loop exprs were not "
6689 if (!CurContext->isDependentContext()) {
6690 // Finalize the clauses that need pre-built expressions for CodeGen.
6691 for (auto C : Clauses) {
6692 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6693 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6694 B.NumIterations, *this, CurScope,
6700 getCurFunction()->setHasBranchProtectedScope();
6701 return OMPTargetTeamsDistributeParallelForSimdDirective::Create(
6702 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6705 StmtResult Sema::ActOnOpenMPTargetTeamsDistributeSimdDirective(
6706 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6707 SourceLocation EndLoc,
6708 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6712 auto *CS = cast<CapturedStmt>(AStmt);
6713 // 1.2.2 OpenMP Language Terminology
6714 // Structured block - An executable statement with a single entry at the
6715 // top and a single exit at the bottom.
6716 // The point of exit cannot be a branch out of the structured block.
6717 // longjmp() and throw() must not violate the entry/exit criteria.
6718 CS->getCapturedDecl()->setNothrow();
6720 OMPLoopDirective::HelperExprs B;
6721 // In presence of clause 'collapse' with number of loops, it will
6722 // define the nested loops number.
6723 auto NestedLoopCount = CheckOpenMPLoop(
6724 OMPD_target_teams_distribute_simd, getCollapseNumberExpr(Clauses),
6725 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack,
6726 VarsWithImplicitDSA, B);
6727 if (NestedLoopCount == 0)
6730 assert((CurContext->isDependentContext() || B.builtAll()) &&
6731 "omp target teams distribute simd loop exprs were not built");
6733 getCurFunction()->setHasBranchProtectedScope();
6734 return OMPTargetTeamsDistributeSimdDirective::Create(
6735 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6738 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
6739 SourceLocation StartLoc,
6740 SourceLocation LParenLoc,
6741 SourceLocation EndLoc) {
6742 OMPClause *Res = nullptr;
6745 Res = ActOnOpenMPFinalClause(Expr, StartLoc, LParenLoc, EndLoc);
6747 case OMPC_num_threads:
6748 Res = ActOnOpenMPNumThreadsClause(Expr, StartLoc, LParenLoc, EndLoc);
6751 Res = ActOnOpenMPSafelenClause(Expr, StartLoc, LParenLoc, EndLoc);
6754 Res = ActOnOpenMPSimdlenClause(Expr, StartLoc, LParenLoc, EndLoc);
6757 Res = ActOnOpenMPCollapseClause(Expr, StartLoc, LParenLoc, EndLoc);
6760 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Expr);
6763 Res = ActOnOpenMPDeviceClause(Expr, StartLoc, LParenLoc, EndLoc);
6765 case OMPC_num_teams:
6766 Res = ActOnOpenMPNumTeamsClause(Expr, StartLoc, LParenLoc, EndLoc);
6768 case OMPC_thread_limit:
6769 Res = ActOnOpenMPThreadLimitClause(Expr, StartLoc, LParenLoc, EndLoc);
6772 Res = ActOnOpenMPPriorityClause(Expr, StartLoc, LParenLoc, EndLoc);
6774 case OMPC_grainsize:
6775 Res = ActOnOpenMPGrainsizeClause(Expr, StartLoc, LParenLoc, EndLoc);
6777 case OMPC_num_tasks:
6778 Res = ActOnOpenMPNumTasksClause(Expr, StartLoc, LParenLoc, EndLoc);
6781 Res = ActOnOpenMPHintClause(Expr, StartLoc, LParenLoc, EndLoc);
6785 case OMPC_proc_bind:
6788 case OMPC_firstprivate:
6789 case OMPC_lastprivate:
6791 case OMPC_reduction:
6795 case OMPC_copyprivate:
6798 case OMPC_mergeable:
6799 case OMPC_threadprivate:
6811 case OMPC_dist_schedule:
6812 case OMPC_defaultmap:
6817 case OMPC_use_device_ptr:
6818 case OMPC_is_device_ptr:
6819 llvm_unreachable("Clause is not allowed.");
6824 // An OpenMP directive such as 'target parallel' has two captured regions:
6825 // for the 'target' and 'parallel' respectively. This function returns
6826 // the region in which to capture expressions associated with a clause.
6827 // A return value of OMPD_unknown signifies that the expression should not
6829 static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
6830 OpenMPDirectiveKind DKind, OpenMPClauseKind CKind,
6831 OpenMPDirectiveKind NameModifier = OMPD_unknown) {
6832 OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
6837 case OMPD_target_parallel:
6838 // If this clause applies to the nested 'parallel' region, capture within
6839 // the 'target' region, otherwise do not capture.
6840 if (NameModifier == OMPD_unknown || NameModifier == OMPD_parallel)
6841 CaptureRegion = OMPD_target;
6845 case OMPD_parallel_sections:
6846 case OMPD_parallel_for:
6847 case OMPD_parallel_for_simd:
6849 case OMPD_target_simd:
6850 case OMPD_target_parallel_for:
6851 case OMPD_target_parallel_for_simd:
6852 case OMPD_target_teams:
6853 case OMPD_target_teams_distribute:
6854 case OMPD_target_teams_distribute_simd:
6855 case OMPD_target_teams_distribute_parallel_for:
6856 case OMPD_target_teams_distribute_parallel_for_simd:
6857 case OMPD_teams_distribute_parallel_for:
6858 case OMPD_teams_distribute_parallel_for_simd:
6859 case OMPD_distribute_parallel_for:
6860 case OMPD_distribute_parallel_for_simd:
6863 case OMPD_taskloop_simd:
6864 case OMPD_target_data:
6865 case OMPD_target_enter_data:
6866 case OMPD_target_exit_data:
6867 case OMPD_target_update:
6868 // Do not capture if-clause expressions.
6870 case OMPD_threadprivate:
6871 case OMPD_taskyield:
6874 case OMPD_cancellation_point:
6876 case OMPD_declare_reduction:
6877 case OMPD_declare_simd:
6878 case OMPD_declare_target:
6879 case OMPD_end_declare_target:
6889 case OMPD_taskgroup:
6890 case OMPD_distribute:
6893 case OMPD_distribute_simd:
6894 case OMPD_teams_distribute:
6895 case OMPD_teams_distribute_simd:
6896 llvm_unreachable("Unexpected OpenMP directive with if-clause");
6898 llvm_unreachable("Unknown OpenMP directive");
6901 case OMPC_num_threads:
6903 case OMPD_target_parallel:
6904 CaptureRegion = OMPD_target;
6908 case OMPD_parallel_sections:
6909 case OMPD_parallel_for:
6910 case OMPD_parallel_for_simd:
6912 case OMPD_target_simd:
6913 case OMPD_target_parallel_for:
6914 case OMPD_target_parallel_for_simd:
6915 case OMPD_target_teams:
6916 case OMPD_target_teams_distribute:
6917 case OMPD_target_teams_distribute_simd:
6918 case OMPD_target_teams_distribute_parallel_for:
6919 case OMPD_target_teams_distribute_parallel_for_simd:
6920 case OMPD_teams_distribute_parallel_for:
6921 case OMPD_teams_distribute_parallel_for_simd:
6922 case OMPD_distribute_parallel_for:
6923 case OMPD_distribute_parallel_for_simd:
6926 case OMPD_taskloop_simd:
6927 case OMPD_target_data:
6928 case OMPD_target_enter_data:
6929 case OMPD_target_exit_data:
6930 case OMPD_target_update:
6931 // Do not capture num_threads-clause expressions.
6933 case OMPD_threadprivate:
6934 case OMPD_taskyield:
6937 case OMPD_cancellation_point:
6939 case OMPD_declare_reduction:
6940 case OMPD_declare_simd:
6941 case OMPD_declare_target:
6942 case OMPD_end_declare_target:
6952 case OMPD_taskgroup:
6953 case OMPD_distribute:
6956 case OMPD_distribute_simd:
6957 case OMPD_teams_distribute:
6958 case OMPD_teams_distribute_simd:
6959 llvm_unreachable("Unexpected OpenMP directive with num_threads-clause");
6961 llvm_unreachable("Unknown OpenMP directive");
6964 case OMPC_num_teams:
6966 case OMPD_target_teams:
6967 CaptureRegion = OMPD_target;
6971 case OMPD_parallel_sections:
6972 case OMPD_parallel_for:
6973 case OMPD_parallel_for_simd:
6975 case OMPD_target_simd:
6976 case OMPD_target_parallel:
6977 case OMPD_target_parallel_for:
6978 case OMPD_target_parallel_for_simd:
6979 case OMPD_target_teams_distribute:
6980 case OMPD_target_teams_distribute_simd:
6981 case OMPD_target_teams_distribute_parallel_for:
6982 case OMPD_target_teams_distribute_parallel_for_simd:
6983 case OMPD_teams_distribute_parallel_for:
6984 case OMPD_teams_distribute_parallel_for_simd:
6985 case OMPD_distribute_parallel_for:
6986 case OMPD_distribute_parallel_for_simd:
6989 case OMPD_taskloop_simd:
6990 case OMPD_target_data:
6991 case OMPD_target_enter_data:
6992 case OMPD_target_exit_data:
6993 case OMPD_target_update:
6995 case OMPD_teams_distribute:
6996 case OMPD_teams_distribute_simd:
6997 // Do not capture num_teams-clause expressions.
6999 case OMPD_threadprivate:
7000 case OMPD_taskyield:
7003 case OMPD_cancellation_point:
7005 case OMPD_declare_reduction:
7006 case OMPD_declare_simd:
7007 case OMPD_declare_target:
7008 case OMPD_end_declare_target:
7017 case OMPD_taskgroup:
7018 case OMPD_distribute:
7021 case OMPD_distribute_simd:
7022 llvm_unreachable("Unexpected OpenMP directive with num_teams-clause");
7024 llvm_unreachable("Unknown OpenMP directive");
7027 case OMPC_thread_limit:
7029 case OMPD_target_teams:
7030 CaptureRegion = OMPD_target;
7034 case OMPD_parallel_sections:
7035 case OMPD_parallel_for:
7036 case OMPD_parallel_for_simd:
7038 case OMPD_target_simd:
7039 case OMPD_target_parallel:
7040 case OMPD_target_parallel_for:
7041 case OMPD_target_parallel_for_simd:
7042 case OMPD_target_teams_distribute:
7043 case OMPD_target_teams_distribute_simd:
7044 case OMPD_target_teams_distribute_parallel_for:
7045 case OMPD_target_teams_distribute_parallel_for_simd:
7046 case OMPD_teams_distribute_parallel_for:
7047 case OMPD_teams_distribute_parallel_for_simd:
7048 case OMPD_distribute_parallel_for:
7049 case OMPD_distribute_parallel_for_simd:
7052 case OMPD_taskloop_simd:
7053 case OMPD_target_data:
7054 case OMPD_target_enter_data:
7055 case OMPD_target_exit_data:
7056 case OMPD_target_update:
7058 case OMPD_teams_distribute:
7059 case OMPD_teams_distribute_simd:
7060 // Do not capture thread_limit-clause expressions.
7062 case OMPD_threadprivate:
7063 case OMPD_taskyield:
7066 case OMPD_cancellation_point:
7068 case OMPD_declare_reduction:
7069 case OMPD_declare_simd:
7070 case OMPD_declare_target:
7071 case OMPD_end_declare_target:
7080 case OMPD_taskgroup:
7081 case OMPD_distribute:
7084 case OMPD_distribute_simd:
7085 llvm_unreachable("Unexpected OpenMP directive with thread_limit-clause");
7087 llvm_unreachable("Unknown OpenMP directive");
7091 case OMPC_dist_schedule:
7092 case OMPC_firstprivate:
7093 case OMPC_lastprivate:
7094 case OMPC_reduction:
7097 case OMPC_proc_bind:
7106 case OMPC_copyprivate:
7110 case OMPC_mergeable:
7111 case OMPC_threadprivate:
7124 case OMPC_grainsize:
7126 case OMPC_num_tasks:
7128 case OMPC_defaultmap:
7133 case OMPC_use_device_ptr:
7134 case OMPC_is_device_ptr:
7135 llvm_unreachable("Unexpected OpenMP clause.");
7137 return CaptureRegion;
7140 OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
7141 Expr *Condition, SourceLocation StartLoc,
7142 SourceLocation LParenLoc,
7143 SourceLocation NameModifierLoc,
7144 SourceLocation ColonLoc,
7145 SourceLocation EndLoc) {
7146 Expr *ValExpr = Condition;
7147 Stmt *HelperValStmt = nullptr;
7148 OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
7149 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
7150 !Condition->isInstantiationDependent() &&
7151 !Condition->containsUnexpandedParameterPack()) {
7152 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
7153 if (Val.isInvalid())
7156 ValExpr = MakeFullExpr(Val.get()).get();
7158 OpenMPDirectiveKind DKind = DSAStack->getCurrentDirective();
7160 getOpenMPCaptureRegionForClause(DKind, OMPC_if, NameModifier);
7161 if (CaptureRegion != OMPD_unknown) {
7162 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7163 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7164 HelperValStmt = buildPreInits(Context, Captures);
7168 return new (Context)
7169 OMPIfClause(NameModifier, ValExpr, HelperValStmt, CaptureRegion, StartLoc,
7170 LParenLoc, NameModifierLoc, ColonLoc, EndLoc);
7173 OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition,
7174 SourceLocation StartLoc,
7175 SourceLocation LParenLoc,
7176 SourceLocation EndLoc) {
7177 Expr *ValExpr = Condition;
7178 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
7179 !Condition->isInstantiationDependent() &&
7180 !Condition->containsUnexpandedParameterPack()) {
7181 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
7182 if (Val.isInvalid())
7185 ValExpr = MakeFullExpr(Val.get()).get();
7188 return new (Context) OMPFinalClause(ValExpr, StartLoc, LParenLoc, EndLoc);
7190 ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc,
7195 class IntConvertDiagnoser : public ICEConvertDiagnoser {
7197 IntConvertDiagnoser()
7198 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false, false, true) {}
7199 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
7200 QualType T) override {
7201 return S.Diag(Loc, diag::err_omp_not_integral) << T;
7203 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
7204 QualType T) override {
7205 return S.Diag(Loc, diag::err_omp_incomplete_type) << T;
7207 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
7209 QualType ConvTy) override {
7210 return S.Diag(Loc, diag::err_omp_explicit_conversion) << T << ConvTy;
7212 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
7213 QualType ConvTy) override {
7214 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
7215 << ConvTy->isEnumeralType() << ConvTy;
7217 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
7218 QualType T) override {
7219 return S.Diag(Loc, diag::err_omp_ambiguous_conversion) << T;
7221 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
7222 QualType ConvTy) override {
7223 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
7224 << ConvTy->isEnumeralType() << ConvTy;
7226 SemaDiagnosticBuilder diagnoseConversion(Sema &, SourceLocation, QualType,
7227 QualType) override {
7228 llvm_unreachable("conversion functions are permitted");
7231 return PerformContextualImplicitConversion(Loc, Op, ConvertDiagnoser);
7234 static bool IsNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef,
7235 OpenMPClauseKind CKind,
7236 bool StrictlyPositive) {
7237 if (!ValExpr->isTypeDependent() && !ValExpr->isValueDependent() &&
7238 !ValExpr->isInstantiationDependent()) {
7239 SourceLocation Loc = ValExpr->getExprLoc();
7241 SemaRef.PerformOpenMPImplicitIntegerConversion(Loc, ValExpr);
7242 if (Value.isInvalid())
7245 ValExpr = Value.get();
7246 // The expression must evaluate to a non-negative integer value.
7247 llvm::APSInt Result;
7248 if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) &&
7249 Result.isSigned() &&
7250 !((!StrictlyPositive && Result.isNonNegative()) ||
7251 (StrictlyPositive && Result.isStrictlyPositive()))) {
7252 SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
7253 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
7254 << ValExpr->getSourceRange();
7261 OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads,
7262 SourceLocation StartLoc,
7263 SourceLocation LParenLoc,
7264 SourceLocation EndLoc) {
7265 Expr *ValExpr = NumThreads;
7266 Stmt *HelperValStmt = nullptr;
7267 OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
7269 // OpenMP [2.5, Restrictions]
7270 // The num_threads expression must evaluate to a positive integer value.
7271 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_threads,
7272 /*StrictlyPositive=*/true))
7275 OpenMPDirectiveKind DKind = DSAStack->getCurrentDirective();
7276 CaptureRegion = getOpenMPCaptureRegionForClause(DKind, OMPC_num_threads);
7277 if (CaptureRegion != OMPD_unknown) {
7278 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7279 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7280 HelperValStmt = buildPreInits(Context, Captures);
7283 return new (Context) OMPNumThreadsClause(
7284 ValExpr, HelperValStmt, CaptureRegion, StartLoc, LParenLoc, EndLoc);
7287 ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
7288 OpenMPClauseKind CKind,
7289 bool StrictlyPositive) {
7292 if (E->isValueDependent() || E->isTypeDependent() ||
7293 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
7295 llvm::APSInt Result;
7296 ExprResult ICE = VerifyIntegerConstantExpression(E, &Result);
7297 if (ICE.isInvalid())
7299 if ((StrictlyPositive && !Result.isStrictlyPositive()) ||
7300 (!StrictlyPositive && !Result.isNonNegative())) {
7301 Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
7302 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
7303 << E->getSourceRange();
7306 if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
7307 Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
7308 << E->getSourceRange();
7311 if (CKind == OMPC_collapse && DSAStack->getAssociatedLoops() == 1)
7312 DSAStack->setAssociatedLoops(Result.getExtValue());
7313 else if (CKind == OMPC_ordered)
7314 DSAStack->setAssociatedLoops(Result.getExtValue());
7318 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
7319 SourceLocation LParenLoc,
7320 SourceLocation EndLoc) {
7321 // OpenMP [2.8.1, simd construct, Description]
7322 // The parameter of the safelen clause must be a constant
7323 // positive integer expression.
7324 ExprResult Safelen = VerifyPositiveIntegerConstantInClause(Len, OMPC_safelen);
7325 if (Safelen.isInvalid())
7327 return new (Context)
7328 OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc);
7331 OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
7332 SourceLocation LParenLoc,
7333 SourceLocation EndLoc) {
7334 // OpenMP [2.8.1, simd construct, Description]
7335 // The parameter of the simdlen clause must be a constant
7336 // positive integer expression.
7337 ExprResult Simdlen = VerifyPositiveIntegerConstantInClause(Len, OMPC_simdlen);
7338 if (Simdlen.isInvalid())
7340 return new (Context)
7341 OMPSimdlenClause(Simdlen.get(), StartLoc, LParenLoc, EndLoc);
7344 OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops,
7345 SourceLocation StartLoc,
7346 SourceLocation LParenLoc,
7347 SourceLocation EndLoc) {
7348 // OpenMP [2.7.1, loop construct, Description]
7349 // OpenMP [2.8.1, simd construct, Description]
7350 // OpenMP [2.9.6, distribute construct, Description]
7351 // The parameter of the collapse clause must be a constant
7352 // positive integer expression.
7353 ExprResult NumForLoopsResult =
7354 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_collapse);
7355 if (NumForLoopsResult.isInvalid())
7357 return new (Context)
7358 OMPCollapseClause(NumForLoopsResult.get(), StartLoc, LParenLoc, EndLoc);
7361 OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc,
7362 SourceLocation EndLoc,
7363 SourceLocation LParenLoc,
7364 Expr *NumForLoops) {
7365 // OpenMP [2.7.1, loop construct, Description]
7366 // OpenMP [2.8.1, simd construct, Description]
7367 // OpenMP [2.9.6, distribute construct, Description]
7368 // The parameter of the ordered clause must be a constant
7369 // positive integer expression if any.
7370 if (NumForLoops && LParenLoc.isValid()) {
7371 ExprResult NumForLoopsResult =
7372 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered);
7373 if (NumForLoopsResult.isInvalid())
7375 NumForLoops = NumForLoopsResult.get();
7377 NumForLoops = nullptr;
7378 DSAStack->setOrderedRegion(/*IsOrdered=*/true, NumForLoops);
7379 return new (Context)
7380 OMPOrderedClause(NumForLoops, StartLoc, LParenLoc, EndLoc);
7383 OMPClause *Sema::ActOnOpenMPSimpleClause(
7384 OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc,
7385 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {
7386 OMPClause *Res = nullptr;
7390 ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument),
7391 ArgumentLoc, StartLoc, LParenLoc, EndLoc);
7393 case OMPC_proc_bind:
7394 Res = ActOnOpenMPProcBindClause(
7395 static_cast<OpenMPProcBindClauseKind>(Argument), ArgumentLoc, StartLoc,
7400 case OMPC_num_threads:
7406 case OMPC_firstprivate:
7407 case OMPC_lastprivate:
7409 case OMPC_reduction:
7413 case OMPC_copyprivate:
7417 case OMPC_mergeable:
7418 case OMPC_threadprivate:
7430 case OMPC_num_teams:
7431 case OMPC_thread_limit:
7433 case OMPC_grainsize:
7435 case OMPC_num_tasks:
7437 case OMPC_dist_schedule:
7438 case OMPC_defaultmap:
7443 case OMPC_use_device_ptr:
7444 case OMPC_is_device_ptr:
7445 llvm_unreachable("Clause is not allowed.");
7451 getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last,
7452 ArrayRef<unsigned> Exclude = llvm::None) {
7454 unsigned Bound = Last >= 2 ? Last - 2 : 0;
7455 unsigned Skipped = Exclude.size();
7456 auto S = Exclude.begin(), E = Exclude.end();
7457 for (unsigned i = First; i < Last; ++i) {
7458 if (std::find(S, E, i) != E) {
7463 Values += getOpenMPSimpleClauseTypeName(K, i);
7465 if (i == Bound - Skipped)
7467 else if (i != Bound + 1 - Skipped)
7473 OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
7474 SourceLocation KindKwLoc,
7475 SourceLocation StartLoc,
7476 SourceLocation LParenLoc,
7477 SourceLocation EndLoc) {
7478 if (Kind == OMPC_DEFAULT_unknown) {
7479 static_assert(OMPC_DEFAULT_unknown > 0,
7480 "OMPC_DEFAULT_unknown not greater than 0");
7481 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
7482 << getListOfPossibleValues(OMPC_default, /*First=*/0,
7483 /*Last=*/OMPC_DEFAULT_unknown)
7484 << getOpenMPClauseName(OMPC_default);
7488 case OMPC_DEFAULT_none:
7489 DSAStack->setDefaultDSANone(KindKwLoc);
7491 case OMPC_DEFAULT_shared:
7492 DSAStack->setDefaultDSAShared(KindKwLoc);
7494 case OMPC_DEFAULT_unknown:
7495 llvm_unreachable("Clause kind is not allowed.");
7498 return new (Context)
7499 OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
7502 OMPClause *Sema::ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
7503 SourceLocation KindKwLoc,
7504 SourceLocation StartLoc,
7505 SourceLocation LParenLoc,
7506 SourceLocation EndLoc) {
7507 if (Kind == OMPC_PROC_BIND_unknown) {
7508 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
7509 << getListOfPossibleValues(OMPC_proc_bind, /*First=*/0,
7510 /*Last=*/OMPC_PROC_BIND_unknown)
7511 << getOpenMPClauseName(OMPC_proc_bind);
7514 return new (Context)
7515 OMPProcBindClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
7518 OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
7519 OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
7520 SourceLocation StartLoc, SourceLocation LParenLoc,
7521 ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc,
7522 SourceLocation EndLoc) {
7523 OMPClause *Res = nullptr;
7526 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
7527 assert(Argument.size() == NumberOfElements &&
7528 ArgumentLoc.size() == NumberOfElements);
7529 Res = ActOnOpenMPScheduleClause(
7530 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier1]),
7531 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier2]),
7532 static_cast<OpenMPScheduleClauseKind>(Argument[ScheduleKind]), Expr,
7533 StartLoc, LParenLoc, ArgumentLoc[Modifier1], ArgumentLoc[Modifier2],
7534 ArgumentLoc[ScheduleKind], DelimLoc, EndLoc);
7537 assert(Argument.size() == 1 && ArgumentLoc.size() == 1);
7538 Res = ActOnOpenMPIfClause(static_cast<OpenMPDirectiveKind>(Argument.back()),
7539 Expr, StartLoc, LParenLoc, ArgumentLoc.back(),
7542 case OMPC_dist_schedule:
7543 Res = ActOnOpenMPDistScheduleClause(
7544 static_cast<OpenMPDistScheduleClauseKind>(Argument.back()), Expr,
7545 StartLoc, LParenLoc, ArgumentLoc.back(), DelimLoc, EndLoc);
7547 case OMPC_defaultmap:
7548 enum { Modifier, DefaultmapKind };
7549 Res = ActOnOpenMPDefaultmapClause(
7550 static_cast<OpenMPDefaultmapClauseModifier>(Argument[Modifier]),
7551 static_cast<OpenMPDefaultmapClauseKind>(Argument[DefaultmapKind]),
7552 StartLoc, LParenLoc, ArgumentLoc[Modifier], ArgumentLoc[DefaultmapKind],
7556 case OMPC_num_threads:
7561 case OMPC_proc_bind:
7563 case OMPC_firstprivate:
7564 case OMPC_lastprivate:
7566 case OMPC_reduction:
7570 case OMPC_copyprivate:
7574 case OMPC_mergeable:
7575 case OMPC_threadprivate:
7587 case OMPC_num_teams:
7588 case OMPC_thread_limit:
7590 case OMPC_grainsize:
7592 case OMPC_num_tasks:
7598 case OMPC_use_device_ptr:
7599 case OMPC_is_device_ptr:
7600 llvm_unreachable("Clause is not allowed.");
7605 static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1,
7606 OpenMPScheduleClauseModifier M2,
7607 SourceLocation M1Loc, SourceLocation M2Loc) {
7608 if (M1 == OMPC_SCHEDULE_MODIFIER_unknown && M1Loc.isValid()) {
7609 SmallVector<unsigned, 2> Excluded;
7610 if (M2 != OMPC_SCHEDULE_MODIFIER_unknown)
7611 Excluded.push_back(M2);
7612 if (M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic)
7613 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_monotonic);
7614 if (M2 == OMPC_SCHEDULE_MODIFIER_monotonic)
7615 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_nonmonotonic);
7616 S.Diag(M1Loc, diag::err_omp_unexpected_clause_value)
7617 << getListOfPossibleValues(OMPC_schedule,
7618 /*First=*/OMPC_SCHEDULE_MODIFIER_unknown + 1,
7619 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7621 << getOpenMPClauseName(OMPC_schedule);
7627 OMPClause *Sema::ActOnOpenMPScheduleClause(
7628 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
7629 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
7630 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
7631 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
7632 if (checkScheduleModifiers(*this, M1, M2, M1Loc, M2Loc) ||
7633 checkScheduleModifiers(*this, M2, M1, M2Loc, M1Loc))
7635 // OpenMP, 2.7.1, Loop Construct, Restrictions
7636 // Either the monotonic modifier or the nonmonotonic modifier can be specified
7638 if ((M1 == M2 && M1 != OMPC_SCHEDULE_MODIFIER_unknown) ||
7639 (M1 == OMPC_SCHEDULE_MODIFIER_monotonic &&
7640 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) ||
7641 (M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic &&
7642 M2 == OMPC_SCHEDULE_MODIFIER_monotonic)) {
7643 Diag(M2Loc, diag::err_omp_unexpected_schedule_modifier)
7644 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M2)
7645 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M1);
7648 if (Kind == OMPC_SCHEDULE_unknown) {
7650 if (M1Loc.isInvalid() && M2Loc.isInvalid()) {
7651 unsigned Exclude[] = {OMPC_SCHEDULE_unknown};
7652 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7653 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7656 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7657 /*Last=*/OMPC_SCHEDULE_unknown);
7659 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
7660 << Values << getOpenMPClauseName(OMPC_schedule);
7663 // OpenMP, 2.7.1, Loop Construct, Restrictions
7664 // The nonmonotonic modifier can only be specified with schedule(dynamic) or
7665 // schedule(guided).
7666 if ((M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
7667 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
7668 Kind != OMPC_SCHEDULE_dynamic && Kind != OMPC_SCHEDULE_guided) {
7669 Diag(M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ? M1Loc : M2Loc,
7670 diag::err_omp_schedule_nonmonotonic_static);
7673 Expr *ValExpr = ChunkSize;
7674 Stmt *HelperValStmt = nullptr;
7676 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
7677 !ChunkSize->isInstantiationDependent() &&
7678 !ChunkSize->containsUnexpandedParameterPack()) {
7679 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
7681 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
7682 if (Val.isInvalid())
7685 ValExpr = Val.get();
7687 // OpenMP [2.7.1, Restrictions]
7688 // chunk_size must be a loop invariant integer expression with a positive
7690 llvm::APSInt Result;
7691 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
7692 if (Result.isSigned() && !Result.isStrictlyPositive()) {
7693 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
7694 << "schedule" << 1 << ChunkSize->getSourceRange();
7697 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
7698 !CurContext->isDependentContext()) {
7699 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7700 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7701 HelperValStmt = buildPreInits(Context, Captures);
7706 return new (Context)
7707 OMPScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, Kind,
7708 ValExpr, HelperValStmt, M1, M1Loc, M2, M2Loc);
7711 OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
7712 SourceLocation StartLoc,
7713 SourceLocation EndLoc) {
7714 OMPClause *Res = nullptr;
7717 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc);
7720 Res = ActOnOpenMPNowaitClause(StartLoc, EndLoc);
7723 Res = ActOnOpenMPUntiedClause(StartLoc, EndLoc);
7725 case OMPC_mergeable:
7726 Res = ActOnOpenMPMergeableClause(StartLoc, EndLoc);
7729 Res = ActOnOpenMPReadClause(StartLoc, EndLoc);
7732 Res = ActOnOpenMPWriteClause(StartLoc, EndLoc);
7735 Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc);
7738 Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc);
7741 Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
7744 Res = ActOnOpenMPThreadsClause(StartLoc, EndLoc);
7747 Res = ActOnOpenMPSIMDClause(StartLoc, EndLoc);
7750 Res = ActOnOpenMPNogroupClause(StartLoc, EndLoc);
7754 case OMPC_num_threads:
7760 case OMPC_firstprivate:
7761 case OMPC_lastprivate:
7763 case OMPC_reduction:
7767 case OMPC_copyprivate:
7769 case OMPC_proc_bind:
7770 case OMPC_threadprivate:
7775 case OMPC_num_teams:
7776 case OMPC_thread_limit:
7778 case OMPC_grainsize:
7779 case OMPC_num_tasks:
7781 case OMPC_dist_schedule:
7782 case OMPC_defaultmap:
7787 case OMPC_use_device_ptr:
7788 case OMPC_is_device_ptr:
7789 llvm_unreachable("Clause is not allowed.");
7794 OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc,
7795 SourceLocation EndLoc) {
7796 DSAStack->setNowaitRegion();
7797 return new (Context) OMPNowaitClause(StartLoc, EndLoc);
7800 OMPClause *Sema::ActOnOpenMPUntiedClause(SourceLocation StartLoc,
7801 SourceLocation EndLoc) {
7802 return new (Context) OMPUntiedClause(StartLoc, EndLoc);
7805 OMPClause *Sema::ActOnOpenMPMergeableClause(SourceLocation StartLoc,
7806 SourceLocation EndLoc) {
7807 return new (Context) OMPMergeableClause(StartLoc, EndLoc);
7810 OMPClause *Sema::ActOnOpenMPReadClause(SourceLocation StartLoc,
7811 SourceLocation EndLoc) {
7812 return new (Context) OMPReadClause(StartLoc, EndLoc);
7815 OMPClause *Sema::ActOnOpenMPWriteClause(SourceLocation StartLoc,
7816 SourceLocation EndLoc) {
7817 return new (Context) OMPWriteClause(StartLoc, EndLoc);
7820 OMPClause *Sema::ActOnOpenMPUpdateClause(SourceLocation StartLoc,
7821 SourceLocation EndLoc) {
7822 return new (Context) OMPUpdateClause(StartLoc, EndLoc);
7825 OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc,
7826 SourceLocation EndLoc) {
7827 return new (Context) OMPCaptureClause(StartLoc, EndLoc);
7830 OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
7831 SourceLocation EndLoc) {
7832 return new (Context) OMPSeqCstClause(StartLoc, EndLoc);
7835 OMPClause *Sema::ActOnOpenMPThreadsClause(SourceLocation StartLoc,
7836 SourceLocation EndLoc) {
7837 return new (Context) OMPThreadsClause(StartLoc, EndLoc);
7840 OMPClause *Sema::ActOnOpenMPSIMDClause(SourceLocation StartLoc,
7841 SourceLocation EndLoc) {
7842 return new (Context) OMPSIMDClause(StartLoc, EndLoc);
7845 OMPClause *Sema::ActOnOpenMPNogroupClause(SourceLocation StartLoc,
7846 SourceLocation EndLoc) {
7847 return new (Context) OMPNogroupClause(StartLoc, EndLoc);
7850 OMPClause *Sema::ActOnOpenMPVarListClause(
7851 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
7852 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc,
7853 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
7854 const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
7855 OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
7856 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
7857 SourceLocation DepLinMapLoc) {
7858 OMPClause *Res = nullptr;
7861 Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7863 case OMPC_firstprivate:
7864 Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7866 case OMPC_lastprivate:
7867 Res = ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7870 Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc);
7872 case OMPC_reduction:
7873 Res = ActOnOpenMPReductionClause(VarList, StartLoc, LParenLoc, ColonLoc,
7874 EndLoc, ReductionIdScopeSpec, ReductionId);
7877 Res = ActOnOpenMPLinearClause(VarList, TailExpr, StartLoc, LParenLoc,
7878 LinKind, DepLinMapLoc, ColonLoc, EndLoc);
7881 Res = ActOnOpenMPAlignedClause(VarList, TailExpr, StartLoc, LParenLoc,
7885 Res = ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, EndLoc);
7887 case OMPC_copyprivate:
7888 Res = ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7891 Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc);
7894 Res = ActOnOpenMPDependClause(DepKind, DepLinMapLoc, ColonLoc, VarList,
7895 StartLoc, LParenLoc, EndLoc);
7898 Res = ActOnOpenMPMapClause(MapTypeModifier, MapType, IsMapTypeImplicit,
7899 DepLinMapLoc, ColonLoc, VarList, StartLoc,
7903 Res = ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
7906 Res = ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc, EndLoc);
7908 case OMPC_use_device_ptr:
7909 Res = ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
7911 case OMPC_is_device_ptr:
7912 Res = ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
7916 case OMPC_num_threads:
7921 case OMPC_proc_bind:
7926 case OMPC_mergeable:
7927 case OMPC_threadprivate:
7936 case OMPC_num_teams:
7937 case OMPC_thread_limit:
7939 case OMPC_grainsize:
7941 case OMPC_num_tasks:
7943 case OMPC_dist_schedule:
7944 case OMPC_defaultmap:
7947 llvm_unreachable("Clause is not allowed.");
7952 ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
7953 ExprObjectKind OK, SourceLocation Loc) {
7954 ExprResult Res = BuildDeclRefExpr(
7955 Capture, Capture->getType().getNonReferenceType(), VK_LValue, Loc);
7956 if (!Res.isUsable())
7958 if (OK == OK_Ordinary && !getLangOpts().CPlusPlus) {
7959 Res = CreateBuiltinUnaryOp(Loc, UO_Deref, Res.get());
7960 if (!Res.isUsable())
7963 if (VK != VK_LValue && Res.get()->isGLValue()) {
7964 Res = DefaultLvalueConversion(Res.get());
7965 if (!Res.isUsable())
7971 static std::pair<ValueDecl *, bool>
7972 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
7973 SourceRange &ERange, bool AllowArraySection = false) {
7974 if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() ||
7975 RefExpr->containsUnexpandedParameterPack())
7976 return std::make_pair(nullptr, true);
7978 // OpenMP [3.1, C/C++]
7979 // A list item is a variable name.
7980 // OpenMP [2.9.3.3, Restrictions, p.1]
7981 // A variable that is part of another variable (as an array or
7982 // structure element) cannot appear in a private clause.
7983 RefExpr = RefExpr->IgnoreParens();
7988 } IsArrayExpr = NoArrayExpr;
7989 if (AllowArraySection) {
7990 if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) {
7991 auto *Base = ASE->getBase()->IgnoreParenImpCasts();
7992 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
7993 Base = TempASE->getBase()->IgnoreParenImpCasts();
7995 IsArrayExpr = ArraySubscript;
7996 } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) {
7997 auto *Base = OASE->getBase()->IgnoreParenImpCasts();
7998 while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base))
7999 Base = TempOASE->getBase()->IgnoreParenImpCasts();
8000 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
8001 Base = TempASE->getBase()->IgnoreParenImpCasts();
8003 IsArrayExpr = OMPArraySection;
8006 ELoc = RefExpr->getExprLoc();
8007 ERange = RefExpr->getSourceRange();
8008 RefExpr = RefExpr->IgnoreParenImpCasts();
8009 auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
8010 auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr);
8011 if ((!DE || !isa<VarDecl>(DE->getDecl())) &&
8012 (S.getCurrentThisType().isNull() || !ME ||
8013 !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) ||
8014 !isa<FieldDecl>(ME->getMemberDecl()))) {
8015 if (IsArrayExpr != NoArrayExpr)
8016 S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr
8021 ? diag::err_omp_expected_var_name_member_expr_or_array_item
8022 : diag::err_omp_expected_var_name_member_expr)
8023 << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange;
8025 return std::make_pair(nullptr, false);
8027 return std::make_pair(DE ? DE->getDecl() : ME->getMemberDecl(), false);
8030 OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
8031 SourceLocation StartLoc,
8032 SourceLocation LParenLoc,
8033 SourceLocation EndLoc) {
8034 SmallVector<Expr *, 8> Vars;
8035 SmallVector<Expr *, 8> PrivateCopies;
8036 for (auto &RefExpr : VarList) {
8037 assert(RefExpr && "NULL expr in OpenMP private clause.");
8038 SourceLocation ELoc;
8040 Expr *SimpleRefExpr = RefExpr;
8041 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8043 // It will be analyzed later.
8044 Vars.push_back(RefExpr);
8045 PrivateCopies.push_back(nullptr);
8047 ValueDecl *D = Res.first;
8051 QualType Type = D->getType();
8052 auto *VD = dyn_cast<VarDecl>(D);
8054 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8055 // A variable that appears in a private clause must not have an incomplete
8056 // type or a reference type.
8057 if (RequireCompleteType(ELoc, Type, diag::err_omp_private_incomplete_type))
8059 Type = Type.getNonReferenceType();
8061 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8063 // Variables with the predetermined data-sharing attributes may not be
8064 // listed in data-sharing attributes clauses, except for the cases
8065 // listed below. For these exceptions only, listing a predetermined
8066 // variable in a data-sharing attribute clause is allowed and overrides
8067 // the variable's predetermined data-sharing attributes.
8068 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8069 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) {
8070 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8071 << getOpenMPClauseName(OMPC_private);
8072 ReportOriginalDSA(*this, DSAStack, D, DVar);
8076 auto CurrDir = DSAStack->getCurrentDirective();
8077 // Variably modified types are not supported for tasks.
8078 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
8079 isOpenMPTaskingDirective(CurrDir)) {
8080 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
8081 << getOpenMPClauseName(OMPC_private) << Type
8082 << getOpenMPDirectiveName(CurrDir);
8085 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8086 Diag(D->getLocation(),
8087 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8092 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
8093 // A list item cannot appear in both a map clause and a data-sharing
8094 // attribute clause on the same construct
8095 if (CurrDir == OMPD_target || CurrDir == OMPD_target_parallel ||
8096 CurrDir == OMPD_target_teams ||
8097 CurrDir == OMPD_target_teams_distribute ||
8098 CurrDir == OMPD_target_teams_distribute_parallel_for ||
8099 CurrDir == OMPD_target_teams_distribute_parallel_for_simd ||
8100 CurrDir == OMPD_target_teams_distribute_simd ||
8101 CurrDir == OMPD_target_parallel_for_simd ||
8102 CurrDir == OMPD_target_parallel_for) {
8103 OpenMPClauseKind ConflictKind;
8104 if (DSAStack->checkMappableExprComponentListsForDecl(
8105 VD, /*CurrentRegionOnly=*/true,
8106 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef,
8107 OpenMPClauseKind WhereFoundClauseKind) -> bool {
8108 ConflictKind = WhereFoundClauseKind;
8111 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
8112 << getOpenMPClauseName(OMPC_private)
8113 << getOpenMPClauseName(ConflictKind)
8114 << getOpenMPDirectiveName(CurrDir);
8115 ReportOriginalDSA(*this, DSAStack, D, DVar);
8120 // OpenMP [2.9.3.3, Restrictions, C/C++, p.1]
8121 // A variable of class type (or array thereof) that appears in a private
8122 // clause requires an accessible, unambiguous default constructor for the
8124 // Generate helper private variable and initialize it with the default
8125 // value. The address of the original variable is replaced by the address of
8126 // the new private variable in CodeGen. This new variable is not added to
8127 // IdResolver, so the code in the OpenMP region uses original variable for
8128 // proper diagnostics.
8129 Type = Type.getUnqualifiedType();
8130 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
8131 D->hasAttrs() ? &D->getAttrs() : nullptr);
8132 ActOnUninitializedDecl(VDPrivate);
8133 if (VDPrivate->isInvalidDecl())
8135 auto VDPrivateRefExpr = buildDeclRefExpr(
8136 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
8138 DeclRefExpr *Ref = nullptr;
8139 if (!VD && !CurContext->isDependentContext())
8140 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8141 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_private, Ref);
8142 Vars.push_back((VD || CurContext->isDependentContext())
8143 ? RefExpr->IgnoreParens()
8145 PrivateCopies.push_back(VDPrivateRefExpr);
8151 return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
8156 class DiagsUninitializedSeveretyRAII {
8158 DiagnosticsEngine &Diags;
8159 SourceLocation SavedLoc;
8163 DiagsUninitializedSeveretyRAII(DiagnosticsEngine &Diags, SourceLocation Loc,
8165 : Diags(Diags), SavedLoc(Loc), IsIgnored(IsIgnored) {
8167 Diags.setSeverity(/*Diag*/ diag::warn_uninit_self_reference_in_init,
8168 /*Map*/ diag::Severity::Ignored, Loc);
8171 ~DiagsUninitializedSeveretyRAII() {
8173 Diags.popMappings(SavedLoc);
8178 OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
8179 SourceLocation StartLoc,
8180 SourceLocation LParenLoc,
8181 SourceLocation EndLoc) {
8182 SmallVector<Expr *, 8> Vars;
8183 SmallVector<Expr *, 8> PrivateCopies;
8184 SmallVector<Expr *, 8> Inits;
8185 SmallVector<Decl *, 4> ExprCaptures;
8186 bool IsImplicitClause =
8187 StartLoc.isInvalid() && LParenLoc.isInvalid() && EndLoc.isInvalid();
8188 auto ImplicitClauseLoc = DSAStack->getConstructLoc();
8190 for (auto &RefExpr : VarList) {
8191 assert(RefExpr && "NULL expr in OpenMP firstprivate clause.");
8192 SourceLocation ELoc;
8194 Expr *SimpleRefExpr = RefExpr;
8195 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8197 // It will be analyzed later.
8198 Vars.push_back(RefExpr);
8199 PrivateCopies.push_back(nullptr);
8200 Inits.push_back(nullptr);
8202 ValueDecl *D = Res.first;
8206 ELoc = IsImplicitClause ? ImplicitClauseLoc : ELoc;
8207 QualType Type = D->getType();
8208 auto *VD = dyn_cast<VarDecl>(D);
8210 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
8211 // A variable that appears in a private clause must not have an incomplete
8212 // type or a reference type.
8213 if (RequireCompleteType(ELoc, Type,
8214 diag::err_omp_firstprivate_incomplete_type))
8216 Type = Type.getNonReferenceType();
8218 // OpenMP [2.9.3.4, Restrictions, C/C++, p.1]
8219 // A variable of class type (or array thereof) that appears in a private
8220 // clause requires an accessible, unambiguous copy constructor for the
8222 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
8224 // If an implicit firstprivate variable found it was checked already.
8225 DSAStackTy::DSAVarData TopDVar;
8226 if (!IsImplicitClause) {
8227 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8229 bool IsConstant = ElemType.isConstant(Context);
8230 // OpenMP [2.4.13, Data-sharing Attribute Clauses]
8231 // A list item that specifies a given variable may not appear in more
8232 // than one clause on the same directive, except that a variable may be
8233 // specified in both firstprivate and lastprivate clauses.
8234 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_firstprivate &&
8235 DVar.CKind != OMPC_lastprivate && DVar.RefExpr) {
8236 Diag(ELoc, diag::err_omp_wrong_dsa)
8237 << getOpenMPClauseName(DVar.CKind)
8238 << getOpenMPClauseName(OMPC_firstprivate);
8239 ReportOriginalDSA(*this, DSAStack, D, DVar);
8243 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8245 // Variables with the predetermined data-sharing attributes may not be
8246 // listed in data-sharing attributes clauses, except for the cases
8247 // listed below. For these exceptions only, listing a predetermined
8248 // variable in a data-sharing attribute clause is allowed and overrides
8249 // the variable's predetermined data-sharing attributes.
8250 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8251 // in a Construct, C/C++, p.2]
8252 // Variables with const-qualified type having no mutable member may be
8253 // listed in a firstprivate clause, even if they are static data members.
8254 if (!(IsConstant || (VD && VD->isStaticDataMember())) && !DVar.RefExpr &&
8255 DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared) {
8256 Diag(ELoc, diag::err_omp_wrong_dsa)
8257 << getOpenMPClauseName(DVar.CKind)
8258 << getOpenMPClauseName(OMPC_firstprivate);
8259 ReportOriginalDSA(*this, DSAStack, D, DVar);
8263 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8264 // OpenMP [2.9.3.4, Restrictions, p.2]
8265 // A list item that is private within a parallel region must not appear
8266 // in a firstprivate clause on a worksharing construct if any of the
8267 // worksharing regions arising from the worksharing construct ever bind
8268 // to any of the parallel regions arising from the parallel construct.
8269 if (isOpenMPWorksharingDirective(CurrDir) &&
8270 !isOpenMPParallelDirective(CurrDir) &&
8271 !isOpenMPTeamsDirective(CurrDir)) {
8272 DVar = DSAStack->getImplicitDSA(D, true);
8273 if (DVar.CKind != OMPC_shared &&
8274 (isOpenMPParallelDirective(DVar.DKind) ||
8275 DVar.DKind == OMPD_unknown)) {
8276 Diag(ELoc, diag::err_omp_required_access)
8277 << getOpenMPClauseName(OMPC_firstprivate)
8278 << getOpenMPClauseName(OMPC_shared);
8279 ReportOriginalDSA(*this, DSAStack, D, DVar);
8283 // OpenMP [2.9.3.4, Restrictions, p.3]
8284 // A list item that appears in a reduction clause of a parallel construct
8285 // must not appear in a firstprivate clause on a worksharing or task
8286 // construct if any of the worksharing or task regions arising from the
8287 // worksharing or task construct ever bind to any of the parallel regions
8288 // arising from the parallel construct.
8289 // OpenMP [2.9.3.4, Restrictions, p.4]
8290 // A list item that appears in a reduction clause in worksharing
8291 // construct must not appear in a firstprivate clause in a task construct
8292 // encountered during execution of any of the worksharing regions arising
8293 // from the worksharing construct.
8294 if (isOpenMPTaskingDirective(CurrDir)) {
8295 DVar = DSAStack->hasInnermostDSA(
8296 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
8297 [](OpenMPDirectiveKind K) -> bool {
8298 return isOpenMPParallelDirective(K) ||
8299 isOpenMPWorksharingDirective(K);
8302 if (DVar.CKind == OMPC_reduction &&
8303 (isOpenMPParallelDirective(DVar.DKind) ||
8304 isOpenMPWorksharingDirective(DVar.DKind))) {
8305 Diag(ELoc, diag::err_omp_parallel_reduction_in_task_firstprivate)
8306 << getOpenMPDirectiveName(DVar.DKind);
8307 ReportOriginalDSA(*this, DSAStack, D, DVar);
8312 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
8313 // A list item that is private within a teams region must not appear in a
8314 // firstprivate clause on a distribute construct if any of the distribute
8315 // regions arising from the distribute construct ever bind to any of the
8316 // teams regions arising from the teams construct.
8317 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3]
8318 // A list item that appears in a reduction clause of a teams construct
8319 // must not appear in a firstprivate clause on a distribute construct if
8320 // any of the distribute regions arising from the distribute construct
8321 // ever bind to any of the teams regions arising from the teams construct.
8322 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
8323 // A list item may appear in a firstprivate or lastprivate clause but not
8325 if (CurrDir == OMPD_distribute) {
8326 DVar = DSAStack->hasInnermostDSA(
8327 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_private; },
8328 [](OpenMPDirectiveKind K) -> bool {
8329 return isOpenMPTeamsDirective(K);
8332 if (DVar.CKind == OMPC_private && isOpenMPTeamsDirective(DVar.DKind)) {
8333 Diag(ELoc, diag::err_omp_firstprivate_distribute_private_teams);
8334 ReportOriginalDSA(*this, DSAStack, D, DVar);
8337 DVar = DSAStack->hasInnermostDSA(
8338 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
8339 [](OpenMPDirectiveKind K) -> bool {
8340 return isOpenMPTeamsDirective(K);
8343 if (DVar.CKind == OMPC_reduction &&
8344 isOpenMPTeamsDirective(DVar.DKind)) {
8345 Diag(ELoc, diag::err_omp_firstprivate_distribute_in_teams_reduction);
8346 ReportOriginalDSA(*this, DSAStack, D, DVar);
8349 DVar = DSAStack->getTopDSA(D, false);
8350 if (DVar.CKind == OMPC_lastprivate) {
8351 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
8352 ReportOriginalDSA(*this, DSAStack, D, DVar);
8356 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
8357 // A list item cannot appear in both a map clause and a data-sharing
8358 // attribute clause on the same construct
8359 if (CurrDir == OMPD_target || CurrDir == OMPD_target_parallel ||
8360 CurrDir == OMPD_target_teams ||
8361 CurrDir == OMPD_target_teams_distribute ||
8362 CurrDir == OMPD_target_teams_distribute_parallel_for ||
8363 CurrDir == OMPD_target_teams_distribute_parallel_for_simd ||
8364 CurrDir == OMPD_target_teams_distribute_simd ||
8365 CurrDir == OMPD_target_parallel_for_simd ||
8366 CurrDir == OMPD_target_parallel_for) {
8367 OpenMPClauseKind ConflictKind;
8368 if (DSAStack->checkMappableExprComponentListsForDecl(
8369 VD, /*CurrentRegionOnly=*/true,
8370 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef,
8371 OpenMPClauseKind WhereFoundClauseKind) -> bool {
8372 ConflictKind = WhereFoundClauseKind;
8375 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
8376 << getOpenMPClauseName(OMPC_firstprivate)
8377 << getOpenMPClauseName(ConflictKind)
8378 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8379 ReportOriginalDSA(*this, DSAStack, D, DVar);
8385 // Variably modified types are not supported for tasks.
8386 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
8387 isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) {
8388 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
8389 << getOpenMPClauseName(OMPC_firstprivate) << Type
8390 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
8393 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
8394 Diag(D->getLocation(),
8395 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
8400 Type = Type.getUnqualifiedType();
8401 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
8402 D->hasAttrs() ? &D->getAttrs() : nullptr);
8403 // Generate helper private variable and initialize it with the value of the
8404 // original variable. The address of the original variable is replaced by
8405 // the address of the new private variable in the CodeGen. This new variable
8406 // is not added to IdResolver, so the code in the OpenMP region uses
8407 // original variable for proper diagnostics and variable capturing.
8408 Expr *VDInitRefExpr = nullptr;
8409 // For arrays generate initializer for single element and replace it by the
8410 // original array element in CodeGen.
8411 if (Type->isArrayType()) {
8413 buildVarDecl(*this, RefExpr->getExprLoc(), ElemType, D->getName());
8414 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, ElemType, ELoc);
8415 auto Init = DefaultLvalueConversion(VDInitRefExpr).get();
8416 ElemType = ElemType.getUnqualifiedType();
8417 auto *VDInitTemp = buildVarDecl(*this, RefExpr->getExprLoc(), ElemType,
8418 ".firstprivate.temp");
8419 InitializedEntity Entity =
8420 InitializedEntity::InitializeVariable(VDInitTemp);
8421 InitializationKind Kind = InitializationKind::CreateCopy(ELoc, ELoc);
8423 InitializationSequence InitSeq(*this, Entity, Kind, Init);
8424 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Init);
8425 if (Result.isInvalid())
8426 VDPrivate->setInvalidDecl();
8428 VDPrivate->setInit(Result.getAs<Expr>());
8429 // Remove temp variable declaration.
8430 Context.Deallocate(VDInitTemp);
8432 auto *VDInit = buildVarDecl(*this, RefExpr->getExprLoc(), Type,
8433 ".firstprivate.temp");
8434 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(),
8435 RefExpr->getExprLoc());
8436 AddInitializerToDecl(VDPrivate,
8437 DefaultLvalueConversion(VDInitRefExpr).get(),
8438 /*DirectInit=*/false);
8440 if (VDPrivate->isInvalidDecl()) {
8441 if (IsImplicitClause) {
8442 Diag(RefExpr->getExprLoc(),
8443 diag::note_omp_task_predetermined_firstprivate_here);
8447 CurContext->addDecl(VDPrivate);
8448 auto VDPrivateRefExpr = buildDeclRefExpr(
8449 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(),
8450 RefExpr->getExprLoc());
8451 DeclRefExpr *Ref = nullptr;
8452 if (!VD && !CurContext->isDependentContext()) {
8453 if (TopDVar.CKind == OMPC_lastprivate)
8454 Ref = TopDVar.PrivateCopy;
8456 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8457 if (!IsOpenMPCapturedDecl(D))
8458 ExprCaptures.push_back(Ref->getDecl());
8461 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref);
8462 Vars.push_back((VD || CurContext->isDependentContext())
8463 ? RefExpr->IgnoreParens()
8465 PrivateCopies.push_back(VDPrivateRefExpr);
8466 Inits.push_back(VDInitRefExpr);
8472 return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8473 Vars, PrivateCopies, Inits,
8474 buildPreInits(Context, ExprCaptures));
8477 OMPClause *Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
8478 SourceLocation StartLoc,
8479 SourceLocation LParenLoc,
8480 SourceLocation EndLoc) {
8481 SmallVector<Expr *, 8> Vars;
8482 SmallVector<Expr *, 8> SrcExprs;
8483 SmallVector<Expr *, 8> DstExprs;
8484 SmallVector<Expr *, 8> AssignmentOps;
8485 SmallVector<Decl *, 4> ExprCaptures;
8486 SmallVector<Expr *, 4> ExprPostUpdates;
8487 for (auto &RefExpr : VarList) {
8488 assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8489 SourceLocation ELoc;
8491 Expr *SimpleRefExpr = RefExpr;
8492 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8494 // It will be analyzed later.
8495 Vars.push_back(RefExpr);
8496 SrcExprs.push_back(nullptr);
8497 DstExprs.push_back(nullptr);
8498 AssignmentOps.push_back(nullptr);
8500 ValueDecl *D = Res.first;
8504 QualType Type = D->getType();
8505 auto *VD = dyn_cast<VarDecl>(D);
8507 // OpenMP [2.14.3.5, Restrictions, C/C++, p.2]
8508 // A variable that appears in a lastprivate clause must not have an
8509 // incomplete type or a reference type.
8510 if (RequireCompleteType(ELoc, Type,
8511 diag::err_omp_lastprivate_incomplete_type))
8513 Type = Type.getNonReferenceType();
8515 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
8517 // Variables with the predetermined data-sharing attributes may not be
8518 // listed in data-sharing attributes clauses, except for the cases
8520 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8521 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_lastprivate &&
8522 DVar.CKind != OMPC_firstprivate &&
8523 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
8524 Diag(ELoc, diag::err_omp_wrong_dsa)
8525 << getOpenMPClauseName(DVar.CKind)
8526 << getOpenMPClauseName(OMPC_lastprivate);
8527 ReportOriginalDSA(*this, DSAStack, D, DVar);
8531 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
8532 // OpenMP [2.14.3.5, Restrictions, p.2]
8533 // A list item that is private within a parallel region, or that appears in
8534 // the reduction clause of a parallel construct, must not appear in a
8535 // lastprivate clause on a worksharing construct if any of the corresponding
8536 // worksharing regions ever binds to any of the corresponding parallel
8538 DSAStackTy::DSAVarData TopDVar = DVar;
8539 if (isOpenMPWorksharingDirective(CurrDir) &&
8540 !isOpenMPParallelDirective(CurrDir) &&
8541 !isOpenMPTeamsDirective(CurrDir)) {
8542 DVar = DSAStack->getImplicitDSA(D, true);
8543 if (DVar.CKind != OMPC_shared) {
8544 Diag(ELoc, diag::err_omp_required_access)
8545 << getOpenMPClauseName(OMPC_lastprivate)
8546 << getOpenMPClauseName(OMPC_shared);
8547 ReportOriginalDSA(*this, DSAStack, D, DVar);
8552 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3]
8553 // A list item may appear in a firstprivate or lastprivate clause but not
8555 if (CurrDir == OMPD_distribute) {
8556 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8557 if (DVar.CKind == OMPC_firstprivate) {
8558 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute);
8559 ReportOriginalDSA(*this, DSAStack, D, DVar);
8564 // OpenMP [2.14.3.5, Restrictions, C++, p.1,2]
8565 // A variable of class type (or array thereof) that appears in a
8566 // lastprivate clause requires an accessible, unambiguous default
8567 // constructor for the class type, unless the list item is also specified
8568 // in a firstprivate clause.
8569 // A variable of class type (or array thereof) that appears in a
8570 // lastprivate clause requires an accessible, unambiguous copy assignment
8571 // operator for the class type.
8572 Type = Context.getBaseElementType(Type).getNonReferenceType();
8573 auto *SrcVD = buildVarDecl(*this, ERange.getBegin(),
8574 Type.getUnqualifiedType(), ".lastprivate.src",
8575 D->hasAttrs() ? &D->getAttrs() : nullptr);
8576 auto *PseudoSrcExpr =
8577 buildDeclRefExpr(*this, SrcVD, Type.getUnqualifiedType(), ELoc);
8579 buildVarDecl(*this, ERange.getBegin(), Type, ".lastprivate.dst",
8580 D->hasAttrs() ? &D->getAttrs() : nullptr);
8581 auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc);
8582 // For arrays generate assignment operation for single element and replace
8583 // it by the original array element in CodeGen.
8584 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, ELoc, BO_Assign,
8585 PseudoDstExpr, PseudoSrcExpr);
8586 if (AssignmentOp.isInvalid())
8588 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
8589 /*DiscardedValue=*/true);
8590 if (AssignmentOp.isInvalid())
8593 DeclRefExpr *Ref = nullptr;
8594 if (!VD && !CurContext->isDependentContext()) {
8595 if (TopDVar.CKind == OMPC_firstprivate)
8596 Ref = TopDVar.PrivateCopy;
8598 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
8599 if (!IsOpenMPCapturedDecl(D))
8600 ExprCaptures.push_back(Ref->getDecl());
8602 if (TopDVar.CKind == OMPC_firstprivate ||
8603 (!IsOpenMPCapturedDecl(D) &&
8604 Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>())) {
8605 ExprResult RefRes = DefaultLvalueConversion(Ref);
8606 if (!RefRes.isUsable())
8608 ExprResult PostUpdateRes =
8609 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, SimpleRefExpr,
8611 if (!PostUpdateRes.isUsable())
8613 ExprPostUpdates.push_back(
8614 IgnoredValueConversions(PostUpdateRes.get()).get());
8617 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_lastprivate, Ref);
8618 Vars.push_back((VD || CurContext->isDependentContext())
8619 ? RefExpr->IgnoreParens()
8621 SrcExprs.push_back(PseudoSrcExpr);
8622 DstExprs.push_back(PseudoDstExpr);
8623 AssignmentOps.push_back(AssignmentOp.get());
8629 return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
8630 Vars, SrcExprs, DstExprs, AssignmentOps,
8631 buildPreInits(Context, ExprCaptures),
8632 buildPostUpdate(*this, ExprPostUpdates));
8635 OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
8636 SourceLocation StartLoc,
8637 SourceLocation LParenLoc,
8638 SourceLocation EndLoc) {
8639 SmallVector<Expr *, 8> Vars;
8640 for (auto &RefExpr : VarList) {
8641 assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
8642 SourceLocation ELoc;
8644 Expr *SimpleRefExpr = RefExpr;
8645 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
8647 // It will be analyzed later.
8648 Vars.push_back(RefExpr);
8650 ValueDecl *D = Res.first;
8654 auto *VD = dyn_cast<VarDecl>(D);
8655 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
8657 // Variables with the predetermined data-sharing attributes may not be
8658 // listed in data-sharing attributes clauses, except for the cases
8659 // listed below. For these exceptions only, listing a predetermined
8660 // variable in a data-sharing attribute clause is allowed and overrides
8661 // the variable's predetermined data-sharing attributes.
8662 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
8663 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared &&
8665 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
8666 << getOpenMPClauseName(OMPC_shared);
8667 ReportOriginalDSA(*this, DSAStack, D, DVar);
8671 DeclRefExpr *Ref = nullptr;
8672 if (!VD && IsOpenMPCapturedDecl(D) && !CurContext->isDependentContext())
8673 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
8674 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_shared, Ref);
8675 Vars.push_back((VD || !Ref || CurContext->isDependentContext())
8676 ? RefExpr->IgnoreParens()
8683 return OMPSharedClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars);
8687 class DSARefChecker : public StmtVisitor<DSARefChecker, bool> {
8691 bool VisitDeclRefExpr(DeclRefExpr *E) {
8692 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) {
8693 DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, false);
8694 if (DVar.CKind == OMPC_shared && !DVar.RefExpr)
8696 if (DVar.CKind != OMPC_unknown)
8698 DSAStackTy::DSAVarData DVarPrivate = Stack->hasDSA(
8699 VD, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
8701 if (DVarPrivate.CKind != OMPC_unknown)
8707 bool VisitStmt(Stmt *S) {
8708 for (auto Child : S->children()) {
8709 if (Child && Visit(Child))
8714 explicit DSARefChecker(DSAStackTy *S) : Stack(S) {}
8719 // Transform MemberExpression for specified FieldDecl of current class to
8720 // DeclRefExpr to specified OMPCapturedExprDecl.
8721 class TransformExprToCaptures : public TreeTransform<TransformExprToCaptures> {
8722 typedef TreeTransform<TransformExprToCaptures> BaseTransform;
8724 DeclRefExpr *CapturedExpr;
8727 TransformExprToCaptures(Sema &SemaRef, ValueDecl *FieldDecl)
8728 : BaseTransform(SemaRef), Field(FieldDecl), CapturedExpr(nullptr) {}
8730 ExprResult TransformMemberExpr(MemberExpr *E) {
8731 if (isa<CXXThisExpr>(E->getBase()->IgnoreParenImpCasts()) &&
8732 E->getMemberDecl() == Field) {
8733 CapturedExpr = buildCapture(SemaRef, Field, E, /*WithInit=*/false);
8734 return CapturedExpr;
8736 return BaseTransform::TransformMemberExpr(E);
8738 DeclRefExpr *getCapturedExpr() { return CapturedExpr; }
8742 template <typename T>
8743 static T filterLookupForUDR(SmallVectorImpl<UnresolvedSet<8>> &Lookups,
8744 const llvm::function_ref<T(ValueDecl *)> &Gen) {
8745 for (auto &Set : Lookups) {
8746 for (auto *D : Set) {
8747 if (auto Res = Gen(cast<ValueDecl>(D)))
8755 buildDeclareReductionRef(Sema &SemaRef, SourceLocation Loc, SourceRange Range,
8756 Scope *S, CXXScopeSpec &ReductionIdScopeSpec,
8757 const DeclarationNameInfo &ReductionId, QualType Ty,
8758 CXXCastPath &BasePath, Expr *UnresolvedReduction) {
8759 if (ReductionIdScopeSpec.isInvalid())
8761 SmallVector<UnresolvedSet<8>, 4> Lookups;
8763 LookupResult Lookup(SemaRef, ReductionId, Sema::LookupOMPReductionName);
8764 Lookup.suppressDiagnostics();
8765 while (S && SemaRef.LookupParsedName(Lookup, S, &ReductionIdScopeSpec)) {
8766 auto *D = Lookup.getRepresentativeDecl();
8769 } while (S && !S->isDeclScope(D));
8772 Lookups.push_back(UnresolvedSet<8>());
8773 Lookups.back().append(Lookup.begin(), Lookup.end());
8776 } else if (auto *ULE =
8777 cast_or_null<UnresolvedLookupExpr>(UnresolvedReduction)) {
8778 Lookups.push_back(UnresolvedSet<8>());
8779 Decl *PrevD = nullptr;
8780 for (auto *D : ULE->decls()) {
8782 Lookups.push_back(UnresolvedSet<8>());
8783 else if (auto *DRD = cast<OMPDeclareReductionDecl>(D))
8784 Lookups.back().addDecl(DRD);
8788 if (Ty->isDependentType() || Ty->isInstantiationDependentType() ||
8789 Ty->containsUnexpandedParameterPack() ||
8790 filterLookupForUDR<bool>(Lookups, [](ValueDecl *D) -> bool {
8791 return !D->isInvalidDecl() &&
8792 (D->getType()->isDependentType() ||
8793 D->getType()->isInstantiationDependentType() ||
8794 D->getType()->containsUnexpandedParameterPack());
8796 UnresolvedSet<8> ResSet;
8797 for (auto &Set : Lookups) {
8798 ResSet.append(Set.begin(), Set.end());
8799 // The last item marks the end of all declarations at the specified scope.
8800 ResSet.addDecl(Set[Set.size() - 1]);
8802 return UnresolvedLookupExpr::Create(
8803 SemaRef.Context, /*NamingClass=*/nullptr,
8804 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), ReductionId,
8805 /*ADL=*/true, /*Overloaded=*/true, ResSet.begin(), ResSet.end());
8807 if (auto *VD = filterLookupForUDR<ValueDecl *>(
8808 Lookups, [&SemaRef, Ty](ValueDecl *D) -> ValueDecl * {
8809 if (!D->isInvalidDecl() &&
8810 SemaRef.Context.hasSameType(D->getType(), Ty))
8814 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8815 if (auto *VD = filterLookupForUDR<ValueDecl *>(
8816 Lookups, [&SemaRef, Ty, Loc](ValueDecl *D) -> ValueDecl * {
8817 if (!D->isInvalidDecl() &&
8818 SemaRef.IsDerivedFrom(Loc, Ty, D->getType()) &&
8819 !Ty.isMoreQualifiedThan(D->getType()))
8823 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
8824 /*DetectVirtual=*/false);
8825 if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) {
8826 if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType(
8827 VD->getType().getUnqualifiedType()))) {
8828 if (SemaRef.CheckBaseClassAccess(Loc, VD->getType(), Ty, Paths.front(),
8830 Sema::AR_inaccessible) {
8831 SemaRef.BuildBasePathArray(Paths, BasePath);
8832 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc);
8837 if (ReductionIdScopeSpec.isSet()) {
8838 SemaRef.Diag(Loc, diag::err_omp_not_resolved_reduction_identifier) << Range;
8844 OMPClause *Sema::ActOnOpenMPReductionClause(
8845 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc,
8846 SourceLocation ColonLoc, SourceLocation EndLoc,
8847 CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId,
8848 ArrayRef<Expr *> UnresolvedReductions) {
8849 auto DN = ReductionId.getName();
8850 auto OOK = DN.getCXXOverloadedOperator();
8851 BinaryOperatorKind BOK = BO_Comma;
8853 // OpenMP [2.14.3.6, reduction clause]
8855 // reduction-identifier is either an identifier or one of the following
8856 // operators: +, -, *, &, |, ^, && and ||
8858 // reduction-identifier is either an id-expression or one of the following
8859 // operators: +, -, *, &, |, ^, && and ||
8860 // FIXME: Only 'min' and 'max' identifiers are supported for now.
8887 case OO_Array_Delete:
8896 case OO_GreaterEqual:
8901 case OO_PercentEqual:
8906 case OO_GreaterGreater:
8907 case OO_LessLessEqual:
8908 case OO_GreaterGreaterEqual:
8910 case OO_ExclaimEqual:
8918 case OO_Conditional:
8920 case NUM_OVERLOADED_OPERATORS:
8921 llvm_unreachable("Unexpected reduction identifier");
8923 if (auto II = DN.getAsIdentifierInfo()) {
8924 if (II->isStr("max"))
8926 else if (II->isStr("min"))
8931 SourceRange ReductionIdRange;
8932 if (ReductionIdScopeSpec.isValid())
8933 ReductionIdRange.setBegin(ReductionIdScopeSpec.getBeginLoc());
8934 ReductionIdRange.setEnd(ReductionId.getEndLoc());
8936 SmallVector<Expr *, 8> Vars;
8937 SmallVector<Expr *, 8> Privates;
8938 SmallVector<Expr *, 8> LHSs;
8939 SmallVector<Expr *, 8> RHSs;
8940 SmallVector<Expr *, 8> ReductionOps;
8941 SmallVector<Decl *, 4> ExprCaptures;
8942 SmallVector<Expr *, 4> ExprPostUpdates;
8943 auto IR = UnresolvedReductions.begin(), ER = UnresolvedReductions.end();
8944 bool FirstIter = true;
8945 for (auto RefExpr : VarList) {
8946 assert(RefExpr && "nullptr expr in OpenMP reduction clause.");
8947 // OpenMP [2.1, C/C++]
8948 // A list item is a variable or array section, subject to the restrictions
8949 // specified in Section 2.4 on page 42 and in each of the sections
8950 // describing clauses and directives for which a list appears.
8951 // OpenMP [2.14.3.3, Restrictions, p.1]
8952 // A variable that is part of another variable (as an array or
8953 // structure element) cannot appear in a private clause.
8954 if (!FirstIter && IR != ER)
8957 SourceLocation ELoc;
8959 Expr *SimpleRefExpr = RefExpr;
8960 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
8961 /*AllowArraySection=*/true);
8963 // It will be analyzed later.
8964 Vars.push_back(RefExpr);
8965 Privates.push_back(nullptr);
8966 LHSs.push_back(nullptr);
8967 RHSs.push_back(nullptr);
8968 // Try to find 'declare reduction' corresponding construct before using
8969 // builtin/overloaded operators.
8970 QualType Type = Context.DependentTy;
8971 CXXCastPath BasePath;
8972 ExprResult DeclareReductionRef = buildDeclareReductionRef(
8973 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
8974 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
8975 if (CurContext->isDependentContext() &&
8976 (DeclareReductionRef.isUnset() ||
8977 isa<UnresolvedLookupExpr>(DeclareReductionRef.get())))
8978 ReductionOps.push_back(DeclareReductionRef.get());
8980 ReductionOps.push_back(nullptr);
8982 ValueDecl *D = Res.first;
8987 auto *ASE = dyn_cast<ArraySubscriptExpr>(RefExpr->IgnoreParens());
8988 auto *OASE = dyn_cast<OMPArraySectionExpr>(RefExpr->IgnoreParens());
8990 Type = ASE->getType().getNonReferenceType();
8992 auto BaseType = OMPArraySectionExpr::getBaseOriginalType(OASE->getBase());
8993 if (auto *ATy = BaseType->getAsArrayTypeUnsafe())
8994 Type = ATy->getElementType();
8996 Type = BaseType->getPointeeType();
8997 Type = Type.getNonReferenceType();
8999 Type = Context.getBaseElementType(D->getType().getNonReferenceType());
9000 auto *VD = dyn_cast<VarDecl>(D);
9002 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
9003 // A variable that appears in a private clause must not have an incomplete
9004 // type or a reference type.
9005 if (RequireCompleteType(ELoc, Type,
9006 diag::err_omp_reduction_incomplete_type))
9008 // OpenMP [2.14.3.6, reduction clause, Restrictions]
9009 // A list item that appears in a reduction clause must not be
9011 if (Type.getNonReferenceType().isConstant(Context)) {
9012 Diag(ELoc, diag::err_omp_const_reduction_list_item)
9013 << getOpenMPClauseName(OMPC_reduction) << Type << ERange;
9014 if (!ASE && !OASE) {
9015 bool IsDecl = !VD ||
9016 VD->isThisDeclarationADefinition(Context) ==
9017 VarDecl::DeclarationOnly;
9018 Diag(D->getLocation(),
9019 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9024 // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]
9025 // If a list-item is a reference type then it must bind to the same object
9026 // for all threads of the team.
9027 if (!ASE && !OASE && VD) {
9028 VarDecl *VDDef = VD->getDefinition();
9029 if (VD->getType()->isReferenceType() && VDDef && VDDef->hasInit()) {
9030 DSARefChecker Check(DSAStack);
9031 if (Check.Visit(VDDef->getInit())) {
9032 Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange;
9033 Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
9039 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
9041 // Variables with the predetermined data-sharing attributes may not be
9042 // listed in data-sharing attributes clauses, except for the cases
9043 // listed below. For these exceptions only, listing a predetermined
9044 // variable in a data-sharing attribute clause is allowed and overrides
9045 // the variable's predetermined data-sharing attributes.
9046 // OpenMP [2.14.3.6, Restrictions, p.3]
9047 // Any number of reduction clauses can be specified on the directive,
9048 // but a list item can appear only once in the reduction clauses for that
9050 DSAStackTy::DSAVarData DVar;
9051 DVar = DSAStack->getTopDSA(D, false);
9052 if (DVar.CKind == OMPC_reduction) {
9053 Diag(ELoc, diag::err_omp_once_referenced)
9054 << getOpenMPClauseName(OMPC_reduction);
9056 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);
9057 } else if (DVar.CKind != OMPC_unknown) {
9058 Diag(ELoc, diag::err_omp_wrong_dsa)
9059 << getOpenMPClauseName(DVar.CKind)
9060 << getOpenMPClauseName(OMPC_reduction);
9061 ReportOriginalDSA(*this, DSAStack, D, DVar);
9065 // OpenMP [2.14.3.6, Restrictions, p.1]
9066 // A list item that appears in a reduction clause of a worksharing
9067 // construct must be shared in the parallel regions to which any of the
9068 // worksharing regions arising from the worksharing construct bind.
9069 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective();
9070 if (isOpenMPWorksharingDirective(CurrDir) &&
9071 !isOpenMPParallelDirective(CurrDir) &&
9072 !isOpenMPTeamsDirective(CurrDir)) {
9073 DVar = DSAStack->getImplicitDSA(D, true);
9074 if (DVar.CKind != OMPC_shared) {
9075 Diag(ELoc, diag::err_omp_required_access)
9076 << getOpenMPClauseName(OMPC_reduction)
9077 << getOpenMPClauseName(OMPC_shared);
9078 ReportOriginalDSA(*this, DSAStack, D, DVar);
9083 // Try to find 'declare reduction' corresponding construct before using
9084 // builtin/overloaded operators.
9085 CXXCastPath BasePath;
9086 ExprResult DeclareReductionRef = buildDeclareReductionRef(
9087 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec,
9088 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR);
9089 if (DeclareReductionRef.isInvalid())
9091 if (CurContext->isDependentContext() &&
9092 (DeclareReductionRef.isUnset() ||
9093 isa<UnresolvedLookupExpr>(DeclareReductionRef.get()))) {
9094 Vars.push_back(RefExpr);
9095 Privates.push_back(nullptr);
9096 LHSs.push_back(nullptr);
9097 RHSs.push_back(nullptr);
9098 ReductionOps.push_back(DeclareReductionRef.get());
9101 if (BOK == BO_Comma && DeclareReductionRef.isUnset()) {
9102 // Not allowed reduction identifier is found.
9103 Diag(ReductionId.getLocStart(),
9104 diag::err_omp_unknown_reduction_identifier)
9105 << Type << ReductionIdRange;
9109 // OpenMP [2.14.3.6, reduction clause, Restrictions]
9110 // The type of a list item that appears in a reduction clause must be valid
9111 // for the reduction-identifier. For a max or min reduction in C, the type
9112 // of the list item must be an allowed arithmetic data type: char, int,
9113 // float, double, or _Bool, possibly modified with long, short, signed, or
9114 // unsigned. For a max or min reduction in C++, the type of the list item
9115 // must be an allowed arithmetic data type: char, wchar_t, int, float,
9116 // double, or bool, possibly modified with long, short, signed, or unsigned.
9117 if (DeclareReductionRef.isUnset()) {
9118 if ((BOK == BO_GT || BOK == BO_LT) &&
9119 !(Type->isScalarType() ||
9120 (getLangOpts().CPlusPlus && Type->isArithmeticType()))) {
9121 Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg)
9122 << getLangOpts().CPlusPlus;
9123 if (!ASE && !OASE) {
9124 bool IsDecl = !VD ||
9125 VD->isThisDeclarationADefinition(Context) ==
9126 VarDecl::DeclarationOnly;
9127 Diag(D->getLocation(),
9128 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9133 if ((BOK == BO_OrAssign || BOK == BO_AndAssign || BOK == BO_XorAssign) &&
9134 !getLangOpts().CPlusPlus && Type->isFloatingType()) {
9135 Diag(ELoc, diag::err_omp_clause_floating_type_arg);
9136 if (!ASE && !OASE) {
9137 bool IsDecl = !VD ||
9138 VD->isThisDeclarationADefinition(Context) ==
9139 VarDecl::DeclarationOnly;
9140 Diag(D->getLocation(),
9141 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9148 Type = Type.getNonLValueExprType(Context).getUnqualifiedType();
9149 auto *LHSVD = buildVarDecl(*this, ELoc, Type, ".reduction.lhs",
9150 D->hasAttrs() ? &D->getAttrs() : nullptr);
9151 auto *RHSVD = buildVarDecl(*this, ELoc, Type, D->getName(),
9152 D->hasAttrs() ? &D->getAttrs() : nullptr);
9153 auto PrivateTy = Type;
9156 D->getType().getNonReferenceType()->isVariablyModifiedType())) {
9157 // For arrays/array sections only:
9158 // Create pseudo array type for private copy. The size for this array will
9159 // be generated during codegen.
9160 // For array subscripts or single variables Private Ty is the same as Type
9161 // (type of the variable or single array element).
9162 PrivateTy = Context.getVariableArrayType(
9163 Type, new (Context) OpaqueValueExpr(SourceLocation(),
9164 Context.getSizeType(), VK_RValue),
9165 ArrayType::Normal, /*IndexTypeQuals=*/0, SourceRange());
9166 } else if (!ASE && !OASE &&
9167 Context.getAsArrayType(D->getType().getNonReferenceType()))
9168 PrivateTy = D->getType().getNonReferenceType();
9170 auto *PrivateVD = buildVarDecl(*this, ELoc, PrivateTy, D->getName(),
9171 D->hasAttrs() ? &D->getAttrs() : nullptr);
9172 // Add initializer for private variable.
9173 Expr *Init = nullptr;
9174 auto *LHSDRE = buildDeclRefExpr(*this, LHSVD, Type, ELoc);
9175 auto *RHSDRE = buildDeclRefExpr(*this, RHSVD, Type, ELoc);
9176 if (DeclareReductionRef.isUsable()) {
9177 auto *DRDRef = DeclareReductionRef.getAs<DeclRefExpr>();
9178 auto *DRD = cast<OMPDeclareReductionDecl>(DRDRef->getDecl());
9179 if (DRD->getInitializer()) {
9181 RHSVD->setInit(DRDRef);
9182 RHSVD->setInitStyle(VarDecl::CallInit);
9190 // '+', '-', '^', '|', '||' reduction ops - initializer is '0'.
9191 if (Type->isScalarType() || Type->isAnyComplexType())
9192 Init = ActOnIntegerConstant(ELoc, /*Val=*/0).get();
9196 if (Type->isScalarType() || Type->isAnyComplexType()) {
9197 // '*' and '&&' reduction ops - initializer is '1'.
9198 Init = ActOnIntegerConstant(ELoc, /*Val=*/1).get();
9202 // '&' reduction op - initializer is '~0'.
9203 QualType OrigType = Type;
9204 if (auto *ComplexTy = OrigType->getAs<ComplexType>())
9205 Type = ComplexTy->getElementType();
9206 if (Type->isRealFloatingType()) {
9207 llvm::APFloat InitValue =
9208 llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type),
9210 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
9212 } else if (Type->isScalarType()) {
9213 auto Size = Context.getTypeSize(Type);
9214 QualType IntTy = Context.getIntTypeForBitwidth(Size, /*Signed=*/0);
9215 llvm::APInt InitValue = llvm::APInt::getAllOnesValue(Size);
9216 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
9218 if (Init && OrigType->isAnyComplexType()) {
9219 // Init = 0xFFFF + 0xFFFFi;
9220 auto *Im = new (Context) ImaginaryLiteral(Init, OrigType);
9221 Init = CreateBuiltinBinOp(ELoc, BO_Add, Init, Im).get();
9228 // 'min' reduction op - initializer is 'Largest representable number in
9229 // the reduction list item type'.
9230 // 'max' reduction op - initializer is 'Least representable number in
9231 // the reduction list item type'.
9232 if (Type->isIntegerType() || Type->isPointerType()) {
9233 bool IsSigned = Type->hasSignedIntegerRepresentation();
9234 auto Size = Context.getTypeSize(Type);
9236 Context.getIntTypeForBitwidth(Size, /*Signed=*/IsSigned);
9237 llvm::APInt InitValue =
9239 ? IsSigned ? llvm::APInt::getSignedMinValue(Size)
9240 : llvm::APInt::getMinValue(Size)
9241 : IsSigned ? llvm::APInt::getSignedMaxValue(Size)
9242 : llvm::APInt::getMaxValue(Size);
9243 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc);
9244 if (Type->isPointerType()) {
9245 // Cast to pointer type.
9246 auto CastExpr = BuildCStyleCastExpr(
9247 SourceLocation(), Context.getTrivialTypeSourceInfo(Type, ELoc),
9248 SourceLocation(), Init);
9249 if (CastExpr.isInvalid())
9251 Init = CastExpr.get();
9253 } else if (Type->isRealFloatingType()) {
9254 llvm::APFloat InitValue = llvm::APFloat::getLargest(
9255 Context.getFloatTypeSemantics(Type), BOK != BO_LT);
9256 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
9284 llvm_unreachable("Unexpected reduction operation");
9287 if (Init && DeclareReductionRef.isUnset()) {
9288 AddInitializerToDecl(RHSVD, Init, /*DirectInit=*/false);
9290 ActOnUninitializedDecl(RHSVD);
9291 if (RHSVD->isInvalidDecl())
9293 if (!RHSVD->hasInit() && DeclareReductionRef.isUnset()) {
9294 Diag(ELoc, diag::err_omp_reduction_id_not_compatible) << Type
9295 << ReductionIdRange;
9298 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9299 Diag(D->getLocation(),
9300 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9304 // Store initializer for single element in private copy. Will be used during
9306 PrivateVD->setInit(RHSVD->getInit());
9307 PrivateVD->setInitStyle(RHSVD->getInitStyle());
9308 auto *PrivateDRE = buildDeclRefExpr(*this, PrivateVD, PrivateTy, ELoc);
9309 ExprResult ReductionOp;
9310 if (DeclareReductionRef.isUsable()) {
9311 QualType RedTy = DeclareReductionRef.get()->getType();
9312 QualType PtrRedTy = Context.getPointerType(RedTy);
9313 ExprResult LHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, LHSDRE);
9314 ExprResult RHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, RHSDRE);
9315 if (!BasePath.empty()) {
9316 LHS = DefaultLvalueConversion(LHS.get());
9317 RHS = DefaultLvalueConversion(RHS.get());
9318 LHS = ImplicitCastExpr::Create(Context, PtrRedTy,
9319 CK_UncheckedDerivedToBase, LHS.get(),
9320 &BasePath, LHS.get()->getValueKind());
9321 RHS = ImplicitCastExpr::Create(Context, PtrRedTy,
9322 CK_UncheckedDerivedToBase, RHS.get(),
9323 &BasePath, RHS.get()->getValueKind());
9325 FunctionProtoType::ExtProtoInfo EPI;
9326 QualType Params[] = {PtrRedTy, PtrRedTy};
9327 QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
9328 auto *OVE = new (Context) OpaqueValueExpr(
9329 ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
9330 DefaultLvalueConversion(DeclareReductionRef.get()).get());
9331 Expr *Args[] = {LHS.get(), RHS.get()};
9332 ReductionOp = new (Context)
9333 CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
9335 ReductionOp = BuildBinOp(DSAStack->getCurScope(),
9336 ReductionId.getLocStart(), BOK, LHSDRE, RHSDRE);
9337 if (ReductionOp.isUsable()) {
9338 if (BOK != BO_LT && BOK != BO_GT) {
9340 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
9341 BO_Assign, LHSDRE, ReductionOp.get());
9343 auto *ConditionalOp = new (Context) ConditionalOperator(
9344 ReductionOp.get(), SourceLocation(), LHSDRE, SourceLocation(),
9345 RHSDRE, Type, VK_LValue, OK_Ordinary);
9347 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(),
9348 BO_Assign, LHSDRE, ConditionalOp);
9350 ReductionOp = ActOnFinishFullExpr(ReductionOp.get());
9352 if (ReductionOp.isInvalid())
9356 DeclRefExpr *Ref = nullptr;
9357 Expr *VarsExpr = RefExpr->IgnoreParens();
9358 if (!VD && !CurContext->isDependentContext()) {
9360 TransformExprToCaptures RebuildToCapture(*this, D);
9362 RebuildToCapture.TransformExpr(RefExpr->IgnoreParens()).get();
9363 Ref = RebuildToCapture.getCapturedExpr();
9366 buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
9368 if (!IsOpenMPCapturedDecl(D)) {
9369 ExprCaptures.push_back(Ref->getDecl());
9370 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
9371 ExprResult RefRes = DefaultLvalueConversion(Ref);
9372 if (!RefRes.isUsable())
9374 ExprResult PostUpdateRes =
9375 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9376 SimpleRefExpr, RefRes.get());
9377 if (!PostUpdateRes.isUsable())
9379 ExprPostUpdates.push_back(
9380 IgnoredValueConversions(PostUpdateRes.get()).get());
9384 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_reduction, Ref);
9385 Vars.push_back(VarsExpr);
9386 Privates.push_back(PrivateDRE);
9387 LHSs.push_back(LHSDRE);
9388 RHSs.push_back(RHSDRE);
9389 ReductionOps.push_back(ReductionOp.get());
9395 return OMPReductionClause::Create(
9396 Context, StartLoc, LParenLoc, ColonLoc, EndLoc, Vars,
9397 ReductionIdScopeSpec.getWithLocInContext(Context), ReductionId, Privates,
9398 LHSs, RHSs, ReductionOps, buildPreInits(Context, ExprCaptures),
9399 buildPostUpdate(*this, ExprPostUpdates));
9402 bool Sema::CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
9403 SourceLocation LinLoc) {
9404 if ((!LangOpts.CPlusPlus && LinKind != OMPC_LINEAR_val) ||
9405 LinKind == OMPC_LINEAR_unknown) {
9406 Diag(LinLoc, diag::err_omp_wrong_linear_modifier) << LangOpts.CPlusPlus;
9412 bool Sema::CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc,
9413 OpenMPLinearClauseKind LinKind,
9415 auto *VD = dyn_cast_or_null<VarDecl>(D);
9416 // A variable must not have an incomplete type or a reference type.
9417 if (RequireCompleteType(ELoc, Type, diag::err_omp_linear_incomplete_type))
9419 if ((LinKind == OMPC_LINEAR_uval || LinKind == OMPC_LINEAR_ref) &&
9420 !Type->isReferenceType()) {
9421 Diag(ELoc, diag::err_omp_wrong_linear_modifier_non_reference)
9422 << Type << getOpenMPSimpleClauseTypeName(OMPC_linear, LinKind);
9425 Type = Type.getNonReferenceType();
9427 // A list item must not be const-qualified.
9428 if (Type.isConstant(Context)) {
9429 Diag(ELoc, diag::err_omp_const_variable)
9430 << getOpenMPClauseName(OMPC_linear);
9434 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9435 Diag(D->getLocation(),
9436 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9442 // A list item must be of integral or pointer type.
9443 Type = Type.getUnqualifiedType().getCanonicalType();
9444 const auto *Ty = Type.getTypePtrOrNull();
9445 if (!Ty || (!Ty->isDependentType() && !Ty->isIntegralType(Context) &&
9446 !Ty->isPointerType())) {
9447 Diag(ELoc, diag::err_omp_linear_expected_int_or_ptr) << Type;
9451 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9452 Diag(D->getLocation(),
9453 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9461 OMPClause *Sema::ActOnOpenMPLinearClause(
9462 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
9463 SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind,
9464 SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9465 SmallVector<Expr *, 8> Vars;
9466 SmallVector<Expr *, 8> Privates;
9467 SmallVector<Expr *, 8> Inits;
9468 SmallVector<Decl *, 4> ExprCaptures;
9469 SmallVector<Expr *, 4> ExprPostUpdates;
9470 if (CheckOpenMPLinearModifier(LinKind, LinLoc))
9471 LinKind = OMPC_LINEAR_val;
9472 for (auto &RefExpr : VarList) {
9473 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9474 SourceLocation ELoc;
9476 Expr *SimpleRefExpr = RefExpr;
9477 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9478 /*AllowArraySection=*/false);
9480 // It will be analyzed later.
9481 Vars.push_back(RefExpr);
9482 Privates.push_back(nullptr);
9483 Inits.push_back(nullptr);
9485 ValueDecl *D = Res.first;
9489 QualType Type = D->getType();
9490 auto *VD = dyn_cast<VarDecl>(D);
9492 // OpenMP [2.14.3.7, linear clause]
9493 // A list-item cannot appear in more than one linear clause.
9494 // A list-item that appears in a linear clause cannot appear in any
9495 // other data-sharing attribute clause.
9496 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false);
9498 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
9499 << getOpenMPClauseName(OMPC_linear);
9500 ReportOriginalDSA(*this, DSAStack, D, DVar);
9504 if (CheckOpenMPLinearDecl(D, ELoc, LinKind, Type))
9506 Type = Type.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9508 // Build private copy of original var.
9509 auto *Private = buildVarDecl(*this, ELoc, Type, D->getName(),
9510 D->hasAttrs() ? &D->getAttrs() : nullptr);
9511 auto *PrivateRef = buildDeclRefExpr(*this, Private, Type, ELoc);
9512 // Build var to save initial value.
9513 VarDecl *Init = buildVarDecl(*this, ELoc, Type, ".linear.start");
9515 DeclRefExpr *Ref = nullptr;
9516 if (!VD && !CurContext->isDependentContext()) {
9517 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
9518 if (!IsOpenMPCapturedDecl(D)) {
9519 ExprCaptures.push_back(Ref->getDecl());
9520 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) {
9521 ExprResult RefRes = DefaultLvalueConversion(Ref);
9522 if (!RefRes.isUsable())
9524 ExprResult PostUpdateRes =
9525 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9526 SimpleRefExpr, RefRes.get());
9527 if (!PostUpdateRes.isUsable())
9529 ExprPostUpdates.push_back(
9530 IgnoredValueConversions(PostUpdateRes.get()).get());
9534 if (LinKind == OMPC_LINEAR_uval)
9535 InitExpr = VD ? VD->getInit() : SimpleRefExpr;
9537 InitExpr = VD ? SimpleRefExpr : Ref;
9538 AddInitializerToDecl(Init, DefaultLvalueConversion(InitExpr).get(),
9539 /*DirectInit=*/false);
9540 auto InitRef = buildDeclRefExpr(*this, Init, Type, ELoc);
9542 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_linear, Ref);
9543 Vars.push_back((VD || CurContext->isDependentContext())
9544 ? RefExpr->IgnoreParens()
9546 Privates.push_back(PrivateRef);
9547 Inits.push_back(InitRef);
9553 Expr *StepExpr = Step;
9554 Expr *CalcStepExpr = nullptr;
9555 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
9556 !Step->isInstantiationDependent() &&
9557 !Step->containsUnexpandedParameterPack()) {
9558 SourceLocation StepLoc = Step->getLocStart();
9559 ExprResult Val = PerformOpenMPImplicitIntegerConversion(StepLoc, Step);
9560 if (Val.isInvalid())
9562 StepExpr = Val.get();
9564 // Build var to save the step value.
9566 buildVarDecl(*this, StepLoc, StepExpr->getType(), ".linear.step");
9567 ExprResult SaveRef =
9568 buildDeclRefExpr(*this, SaveVar, StepExpr->getType(), StepLoc);
9569 ExprResult CalcStep =
9570 BuildBinOp(CurScope, StepLoc, BO_Assign, SaveRef.get(), StepExpr);
9571 CalcStep = ActOnFinishFullExpr(CalcStep.get());
9573 // Warn about zero linear step (it would be probably better specified as
9574 // making corresponding variables 'const').
9575 llvm::APSInt Result;
9576 bool IsConstant = StepExpr->isIntegerConstantExpr(Result, Context);
9577 if (IsConstant && !Result.isNegative() && !Result.isStrictlyPositive())
9578 Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0]
9579 << (Vars.size() > 1);
9580 if (!IsConstant && CalcStep.isUsable()) {
9581 // Calculate the step beforehand instead of doing this on each iteration.
9582 // (This is not used if the number of iterations may be kfold-ed).
9583 CalcStepExpr = CalcStep.get();
9587 return OMPLinearClause::Create(Context, StartLoc, LParenLoc, LinKind, LinLoc,
9588 ColonLoc, EndLoc, Vars, Privates, Inits,
9589 StepExpr, CalcStepExpr,
9590 buildPreInits(Context, ExprCaptures),
9591 buildPostUpdate(*this, ExprPostUpdates));
9594 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
9595 Expr *NumIterations, Sema &SemaRef,
9596 Scope *S, DSAStackTy *Stack) {
9597 // Walk the vars and build update/final expressions for the CodeGen.
9598 SmallVector<Expr *, 8> Updates;
9599 SmallVector<Expr *, 8> Finals;
9600 Expr *Step = Clause.getStep();
9601 Expr *CalcStep = Clause.getCalcStep();
9602 // OpenMP [2.14.3.7, linear clause]
9603 // If linear-step is not specified it is assumed to be 1.
9604 if (Step == nullptr)
9605 Step = SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get();
9606 else if (CalcStep) {
9607 Step = cast<BinaryOperator>(CalcStep)->getLHS();
9609 bool HasErrors = false;
9610 auto CurInit = Clause.inits().begin();
9611 auto CurPrivate = Clause.privates().begin();
9612 auto LinKind = Clause.getModifier();
9613 for (auto &RefExpr : Clause.varlists()) {
9614 SourceLocation ELoc;
9616 Expr *SimpleRefExpr = RefExpr;
9617 auto Res = getPrivateItem(SemaRef, SimpleRefExpr, ELoc, ERange,
9618 /*AllowArraySection=*/false);
9619 ValueDecl *D = Res.first;
9620 if (Res.second || !D) {
9621 Updates.push_back(nullptr);
9622 Finals.push_back(nullptr);
9626 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(D)) {
9627 D = cast<MemberExpr>(CED->getInit()->IgnoreParenImpCasts())
9630 auto &&Info = Stack->isLoopControlVariable(D);
9631 Expr *InitExpr = *CurInit;
9633 // Build privatized reference to the current linear var.
9634 auto *DE = cast<DeclRefExpr>(SimpleRefExpr);
9636 if (LinKind == OMPC_LINEAR_uval)
9637 CapturedRef = cast<VarDecl>(DE->getDecl())->getInit();
9640 buildDeclRefExpr(SemaRef, cast<VarDecl>(DE->getDecl()),
9641 DE->getType().getUnqualifiedType(), DE->getExprLoc(),
9642 /*RefersToCapture=*/true);
9644 // Build update: Var = InitExpr + IV * Step
9648 BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), *CurPrivate,
9649 InitExpr, IV, Step, /* Subtract */ false);
9651 Update = *CurPrivate;
9652 Update = SemaRef.ActOnFinishFullExpr(Update.get(), DE->getLocStart(),
9653 /*DiscardedValue=*/true);
9655 // Build final: Var = InitExpr + NumIterations * Step
9658 Final = BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), CapturedRef,
9659 InitExpr, NumIterations, Step,
9660 /* Subtract */ false);
9662 Final = *CurPrivate;
9663 Final = SemaRef.ActOnFinishFullExpr(Final.get(), DE->getLocStart(),
9664 /*DiscardedValue=*/true);
9666 if (!Update.isUsable() || !Final.isUsable()) {
9667 Updates.push_back(nullptr);
9668 Finals.push_back(nullptr);
9671 Updates.push_back(Update.get());
9672 Finals.push_back(Final.get());
9677 Clause.setUpdates(Updates);
9678 Clause.setFinals(Finals);
9682 OMPClause *Sema::ActOnOpenMPAlignedClause(
9683 ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc,
9684 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {
9686 SmallVector<Expr *, 8> Vars;
9687 for (auto &RefExpr : VarList) {
9688 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9689 SourceLocation ELoc;
9691 Expr *SimpleRefExpr = RefExpr;
9692 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9693 /*AllowArraySection=*/false);
9695 // It will be analyzed later.
9696 Vars.push_back(RefExpr);
9698 ValueDecl *D = Res.first;
9702 QualType QType = D->getType();
9703 auto *VD = dyn_cast<VarDecl>(D);
9705 // OpenMP [2.8.1, simd construct, Restrictions]
9706 // The type of list items appearing in the aligned clause must be
9707 // array, pointer, reference to array, or reference to pointer.
9708 QType = QType.getNonReferenceType().getUnqualifiedType().getCanonicalType();
9709 const Type *Ty = QType.getTypePtrOrNull();
9710 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
9711 Diag(ELoc, diag::err_omp_aligned_expected_array_or_ptr)
9712 << QType << getLangOpts().CPlusPlus << ERange;
9715 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9716 Diag(D->getLocation(),
9717 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9722 // OpenMP [2.8.1, simd construct, Restrictions]
9723 // A list-item cannot appear in more than one aligned clause.
9724 if (Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) {
9725 Diag(ELoc, diag::err_omp_aligned_twice) << 0 << ERange;
9726 Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa)
9727 << getOpenMPClauseName(OMPC_aligned);
9731 DeclRefExpr *Ref = nullptr;
9732 if (!VD && IsOpenMPCapturedDecl(D))
9733 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
9734 Vars.push_back(DefaultFunctionArrayConversion(
9735 (VD || !Ref) ? RefExpr->IgnoreParens() : Ref)
9739 // OpenMP [2.8.1, simd construct, Description]
9740 // The parameter of the aligned clause, alignment, must be a constant
9741 // positive integer expression.
9742 // If no optional parameter is specified, implementation-defined default
9743 // alignments for SIMD instructions on the target platforms are assumed.
9744 if (Alignment != nullptr) {
9745 ExprResult AlignResult =
9746 VerifyPositiveIntegerConstantInClause(Alignment, OMPC_aligned);
9747 if (AlignResult.isInvalid())
9749 Alignment = AlignResult.get();
9754 return OMPAlignedClause::Create(Context, StartLoc, LParenLoc, ColonLoc,
9755 EndLoc, Vars, Alignment);
9758 OMPClause *Sema::ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
9759 SourceLocation StartLoc,
9760 SourceLocation LParenLoc,
9761 SourceLocation EndLoc) {
9762 SmallVector<Expr *, 8> Vars;
9763 SmallVector<Expr *, 8> SrcExprs;
9764 SmallVector<Expr *, 8> DstExprs;
9765 SmallVector<Expr *, 8> AssignmentOps;
9766 for (auto &RefExpr : VarList) {
9767 assert(RefExpr && "NULL expr in OpenMP copyin clause.");
9768 if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
9769 // It will be analyzed later.
9770 Vars.push_back(RefExpr);
9771 SrcExprs.push_back(nullptr);
9772 DstExprs.push_back(nullptr);
9773 AssignmentOps.push_back(nullptr);
9777 SourceLocation ELoc = RefExpr->getExprLoc();
9778 // OpenMP [2.1, C/C++]
9779 // A list item is a variable name.
9780 // OpenMP [2.14.4.1, Restrictions, p.1]
9781 // A list item that appears in a copyin clause must be threadprivate.
9782 DeclRefExpr *DE = dyn_cast<DeclRefExpr>(RefExpr);
9783 if (!DE || !isa<VarDecl>(DE->getDecl())) {
9784 Diag(ELoc, diag::err_omp_expected_var_name_member_expr)
9785 << 0 << RefExpr->getSourceRange();
9789 Decl *D = DE->getDecl();
9790 VarDecl *VD = cast<VarDecl>(D);
9792 QualType Type = VD->getType();
9793 if (Type->isDependentType() || Type->isInstantiationDependentType()) {
9794 // It will be analyzed later.
9796 SrcExprs.push_back(nullptr);
9797 DstExprs.push_back(nullptr);
9798 AssignmentOps.push_back(nullptr);
9802 // OpenMP [2.14.4.1, Restrictions, C/C++, p.1]
9803 // A list item that appears in a copyin clause must be threadprivate.
9804 if (!DSAStack->isThreadPrivate(VD)) {
9805 Diag(ELoc, diag::err_omp_required_access)
9806 << getOpenMPClauseName(OMPC_copyin)
9807 << getOpenMPDirectiveName(OMPD_threadprivate);
9811 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
9812 // A variable of class type (or array thereof) that appears in a
9813 // copyin clause requires an accessible, unambiguous copy assignment
9814 // operator for the class type.
9815 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType();
9817 buildVarDecl(*this, DE->getLocStart(), ElemType.getUnqualifiedType(),
9818 ".copyin.src", VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9819 auto *PseudoSrcExpr = buildDeclRefExpr(
9820 *this, SrcVD, ElemType.getUnqualifiedType(), DE->getExprLoc());
9822 buildVarDecl(*this, DE->getLocStart(), ElemType, ".copyin.dst",
9823 VD->hasAttrs() ? &VD->getAttrs() : nullptr);
9824 auto *PseudoDstExpr =
9825 buildDeclRefExpr(*this, DstVD, ElemType, DE->getExprLoc());
9826 // For arrays generate assignment operation for single element and replace
9827 // it by the original array element in CodeGen.
9828 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, DE->getExprLoc(), BO_Assign,
9829 PseudoDstExpr, PseudoSrcExpr);
9830 if (AssignmentOp.isInvalid())
9832 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), DE->getExprLoc(),
9833 /*DiscardedValue=*/true);
9834 if (AssignmentOp.isInvalid())
9837 DSAStack->addDSA(VD, DE, OMPC_copyin);
9839 SrcExprs.push_back(PseudoSrcExpr);
9840 DstExprs.push_back(PseudoDstExpr);
9841 AssignmentOps.push_back(AssignmentOp.get());
9847 return OMPCopyinClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
9848 SrcExprs, DstExprs, AssignmentOps);
9851 OMPClause *Sema::ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
9852 SourceLocation StartLoc,
9853 SourceLocation LParenLoc,
9854 SourceLocation EndLoc) {
9855 SmallVector<Expr *, 8> Vars;
9856 SmallVector<Expr *, 8> SrcExprs;
9857 SmallVector<Expr *, 8> DstExprs;
9858 SmallVector<Expr *, 8> AssignmentOps;
9859 for (auto &RefExpr : VarList) {
9860 assert(RefExpr && "NULL expr in OpenMP linear clause.");
9861 SourceLocation ELoc;
9863 Expr *SimpleRefExpr = RefExpr;
9864 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange,
9865 /*AllowArraySection=*/false);
9867 // It will be analyzed later.
9868 Vars.push_back(RefExpr);
9869 SrcExprs.push_back(nullptr);
9870 DstExprs.push_back(nullptr);
9871 AssignmentOps.push_back(nullptr);
9873 ValueDecl *D = Res.first;
9877 QualType Type = D->getType();
9878 auto *VD = dyn_cast<VarDecl>(D);
9880 // OpenMP [2.14.4.2, Restrictions, p.2]
9881 // A list item that appears in a copyprivate clause may not appear in a
9882 // private or firstprivate clause on the single construct.
9883 if (!VD || !DSAStack->isThreadPrivate(VD)) {
9884 auto DVar = DSAStack->getTopDSA(D, false);
9885 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_copyprivate &&
9887 Diag(ELoc, diag::err_omp_wrong_dsa)
9888 << getOpenMPClauseName(DVar.CKind)
9889 << getOpenMPClauseName(OMPC_copyprivate);
9890 ReportOriginalDSA(*this, DSAStack, D, DVar);
9894 // OpenMP [2.11.4.2, Restrictions, p.1]
9895 // All list items that appear in a copyprivate clause must be either
9896 // threadprivate or private in the enclosing context.
9897 if (DVar.CKind == OMPC_unknown) {
9898 DVar = DSAStack->getImplicitDSA(D, false);
9899 if (DVar.CKind == OMPC_shared) {
9900 Diag(ELoc, diag::err_omp_required_access)
9901 << getOpenMPClauseName(OMPC_copyprivate)
9902 << "threadprivate or private in the enclosing context";
9903 ReportOriginalDSA(*this, DSAStack, D, DVar);
9909 // Variably modified types are not supported.
9910 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType()) {
9911 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
9912 << getOpenMPClauseName(OMPC_copyprivate) << Type
9913 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
9916 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
9917 Diag(D->getLocation(),
9918 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
9923 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2]
9924 // A variable of class type (or array thereof) that appears in a
9925 // copyin clause requires an accessible, unambiguous copy assignment
9926 // operator for the class type.
9927 Type = Context.getBaseElementType(Type.getNonReferenceType())
9928 .getUnqualifiedType();
9930 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.src",
9931 D->hasAttrs() ? &D->getAttrs() : nullptr);
9932 auto *PseudoSrcExpr = buildDeclRefExpr(*this, SrcVD, Type, ELoc);
9934 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.dst",
9935 D->hasAttrs() ? &D->getAttrs() : nullptr);
9936 auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc);
9937 auto AssignmentOp = BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign,
9938 PseudoDstExpr, PseudoSrcExpr);
9939 if (AssignmentOp.isInvalid())
9941 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc,
9942 /*DiscardedValue=*/true);
9943 if (AssignmentOp.isInvalid())
9946 // No need to mark vars as copyprivate, they are already threadprivate or
9947 // implicitly private.
9948 assert(VD || IsOpenMPCapturedDecl(D));
9950 VD ? RefExpr->IgnoreParens()
9951 : buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false));
9952 SrcExprs.push_back(PseudoSrcExpr);
9953 DstExprs.push_back(PseudoDstExpr);
9954 AssignmentOps.push_back(AssignmentOp.get());
9960 return OMPCopyprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
9961 Vars, SrcExprs, DstExprs, AssignmentOps);
9964 OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
9965 SourceLocation StartLoc,
9966 SourceLocation LParenLoc,
9967 SourceLocation EndLoc) {
9968 if (VarList.empty())
9971 return OMPFlushClause::Create(Context, StartLoc, LParenLoc, EndLoc, VarList);
9975 Sema::ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind,
9976 SourceLocation DepLoc, SourceLocation ColonLoc,
9977 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9978 SourceLocation LParenLoc, SourceLocation EndLoc) {
9979 if (DSAStack->getCurrentDirective() == OMPD_ordered &&
9980 DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink) {
9981 Diag(DepLoc, diag::err_omp_unexpected_clause_value)
9982 << "'source' or 'sink'" << getOpenMPClauseName(OMPC_depend);
9985 if (DSAStack->getCurrentDirective() != OMPD_ordered &&
9986 (DepKind == OMPC_DEPEND_unknown || DepKind == OMPC_DEPEND_source ||
9987 DepKind == OMPC_DEPEND_sink)) {
9988 unsigned Except[] = {OMPC_DEPEND_source, OMPC_DEPEND_sink};
9989 Diag(DepLoc, diag::err_omp_unexpected_clause_value)
9990 << getListOfPossibleValues(OMPC_depend, /*First=*/0,
9991 /*Last=*/OMPC_DEPEND_unknown, Except)
9992 << getOpenMPClauseName(OMPC_depend);
9995 SmallVector<Expr *, 8> Vars;
9996 DSAStackTy::OperatorOffsetTy OpsOffs;
9997 llvm::APSInt DepCounter(/*BitWidth=*/32);
9998 llvm::APSInt TotalDepCount(/*BitWidth=*/32);
9999 if (DepKind == OMPC_DEPEND_sink) {
10000 if (auto *OrderedCountExpr = DSAStack->getParentOrderedRegionParam()) {
10001 TotalDepCount = OrderedCountExpr->EvaluateKnownConstInt(Context);
10002 TotalDepCount.setIsUnsigned(/*Val=*/true);
10005 if ((DepKind != OMPC_DEPEND_sink && DepKind != OMPC_DEPEND_source) ||
10006 DSAStack->getParentOrderedRegionParam()) {
10007 for (auto &RefExpr : VarList) {
10008 assert(RefExpr && "NULL expr in OpenMP shared clause.");
10009 if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
10010 // It will be analyzed later.
10011 Vars.push_back(RefExpr);
10015 SourceLocation ELoc = RefExpr->getExprLoc();
10016 auto *SimpleExpr = RefExpr->IgnoreParenCasts();
10017 if (DepKind == OMPC_DEPEND_sink) {
10018 if (DepCounter >= TotalDepCount) {
10019 Diag(ELoc, diag::err_omp_depend_sink_unexpected_expr);
10023 // OpenMP [2.13.9, Summary]
10024 // depend(dependence-type : vec), where dependence-type is:
10025 // 'sink' and where vec is the iteration vector, which has the form:
10026 // x1 [+- d1], x2 [+- d2 ], . . . , xn [+- dn]
10027 // where n is the value specified by the ordered clause in the loop
10028 // directive, xi denotes the loop iteration variable of the i-th nested
10029 // loop associated with the loop directive, and di is a constant
10030 // non-negative integer.
10031 if (CurContext->isDependentContext()) {
10032 // It will be analyzed later.
10033 Vars.push_back(RefExpr);
10036 SimpleExpr = SimpleExpr->IgnoreImplicit();
10037 OverloadedOperatorKind OOK = OO_None;
10038 SourceLocation OOLoc;
10039 Expr *LHS = SimpleExpr;
10040 Expr *RHS = nullptr;
10041 if (auto *BO = dyn_cast<BinaryOperator>(SimpleExpr)) {
10042 OOK = BinaryOperator::getOverloadedOperator(BO->getOpcode());
10043 OOLoc = BO->getOperatorLoc();
10044 LHS = BO->getLHS()->IgnoreParenImpCasts();
10045 RHS = BO->getRHS()->IgnoreParenImpCasts();
10046 } else if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(SimpleExpr)) {
10047 OOK = OCE->getOperator();
10048 OOLoc = OCE->getOperatorLoc();
10049 LHS = OCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
10050 RHS = OCE->getArg(/*Arg=*/1)->IgnoreParenImpCasts();
10051 } else if (auto *MCE = dyn_cast<CXXMemberCallExpr>(SimpleExpr)) {
10052 OOK = MCE->getMethodDecl()
10055 .getCXXOverloadedOperator();
10056 OOLoc = MCE->getCallee()->getExprLoc();
10057 LHS = MCE->getImplicitObjectArgument()->IgnoreParenImpCasts();
10058 RHS = MCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts();
10060 SourceLocation ELoc;
10061 SourceRange ERange;
10062 auto Res = getPrivateItem(*this, LHS, ELoc, ERange,
10063 /*AllowArraySection=*/false);
10065 // It will be analyzed later.
10066 Vars.push_back(RefExpr);
10068 ValueDecl *D = Res.first;
10072 if (OOK != OO_Plus && OOK != OO_Minus && (RHS || OOK != OO_None)) {
10073 Diag(OOLoc, diag::err_omp_depend_sink_expected_plus_minus);
10077 ExprResult RHSRes = VerifyPositiveIntegerConstantInClause(
10078 RHS, OMPC_depend, /*StrictlyPositive=*/false);
10079 if (RHSRes.isInvalid())
10082 if (!CurContext->isDependentContext() &&
10083 DSAStack->getParentOrderedRegionParam() &&
10084 DepCounter != DSAStack->isParentLoopControlVariable(D).first) {
10085 Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration)
10086 << DSAStack->getParentLoopControlVariable(
10087 DepCounter.getZExtValue());
10090 OpsOffs.push_back({RHS, OOK});
10092 // OpenMP [2.11.1.1, Restrictions, p.3]
10093 // A variable that is part of another variable (such as a field of a
10094 // structure) but is not an array element or an array section cannot
10095 // appear in a depend clause.
10096 auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr);
10097 auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr);
10098 auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr);
10099 if (!RefExpr->IgnoreParenImpCasts()->isLValue() ||
10100 (!ASE && !DE && !OASE) || (DE && !isa<VarDecl>(DE->getDecl())) ||
10104 .getNonReferenceType()
10105 ->isPointerType() &&
10106 !ASE->getBase()->getType().getNonReferenceType()->isArrayType())) {
10107 Diag(ELoc, diag::err_omp_expected_var_name_member_expr_or_array_item)
10108 << 0 << RefExpr->getSourceRange();
10112 Vars.push_back(RefExpr->IgnoreParenImpCasts());
10115 if (!CurContext->isDependentContext() && DepKind == OMPC_DEPEND_sink &&
10116 TotalDepCount > VarList.size() &&
10117 DSAStack->getParentOrderedRegionParam()) {
10118 Diag(EndLoc, diag::err_omp_depend_sink_expected_loop_iteration)
10119 << DSAStack->getParentLoopControlVariable(VarList.size() + 1);
10121 if (DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink &&
10125 auto *C = OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10126 DepKind, DepLoc, ColonLoc, Vars);
10127 if (DepKind == OMPC_DEPEND_sink || DepKind == OMPC_DEPEND_source)
10128 DSAStack->addDoacrossDependClause(C, OpsOffs);
10132 OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
10133 SourceLocation LParenLoc,
10134 SourceLocation EndLoc) {
10135 Expr *ValExpr = Device;
10137 // OpenMP [2.9.1, Restrictions]
10138 // The device expression must evaluate to a non-negative integer value.
10139 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_device,
10140 /*StrictlyPositive=*/false))
10143 return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc);
10146 static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc,
10147 DSAStackTy *Stack, CXXRecordDecl *RD) {
10148 if (!RD || RD->isInvalidDecl())
10151 auto QTy = SemaRef.Context.getRecordType(RD);
10152 if (RD->isDynamicClass()) {
10153 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10154 SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target);
10158 bool IsCorrect = true;
10159 for (auto *I : DC->decls()) {
10161 if (auto *MD = dyn_cast<CXXMethodDecl>(I)) {
10162 if (MD->isStatic()) {
10163 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10164 SemaRef.Diag(MD->getLocation(),
10165 diag::note_omp_static_member_in_target);
10168 } else if (auto *VD = dyn_cast<VarDecl>(I)) {
10169 if (VD->isStaticDataMember()) {
10170 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
10171 SemaRef.Diag(VD->getLocation(),
10172 diag::note_omp_static_member_in_target);
10179 for (auto &I : RD->bases()) {
10180 if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack,
10181 I.getType()->getAsCXXRecordDecl()))
10187 static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
10188 DSAStackTy *Stack, QualType QTy) {
10190 if (QTy->isIncompleteType(&ND)) {
10191 SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
10193 } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) {
10194 if (!RD->isInvalidDecl() && !IsCXXRecordForMappable(SemaRef, SL, Stack, RD))
10200 /// \brief Return true if it can be proven that the provided array expression
10201 /// (array section or array subscript) does NOT specify the whole size of the
10202 /// array whose base type is \a BaseQTy.
10203 static bool CheckArrayExpressionDoesNotReferToWholeSize(Sema &SemaRef,
10205 QualType BaseQTy) {
10206 auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
10208 // If this is an array subscript, it refers to the whole size if the size of
10209 // the dimension is constant and equals 1. Also, an array section assumes the
10210 // format of an array subscript if no colon is used.
10211 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid())) {
10212 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
10213 return ATy->getSize().getSExtValue() != 1;
10214 // Size can't be evaluated statically.
10218 assert(OASE && "Expecting array section if not an array subscript.");
10219 auto *LowerBound = OASE->getLowerBound();
10220 auto *Length = OASE->getLength();
10222 // If there is a lower bound that does not evaluates to zero, we are not
10223 // covering the whole dimension.
10225 llvm::APSInt ConstLowerBound;
10226 if (!LowerBound->EvaluateAsInt(ConstLowerBound, SemaRef.getASTContext()))
10227 return false; // Can't get the integer value as a constant.
10228 if (ConstLowerBound.getSExtValue())
10232 // If we don't have a length we covering the whole dimension.
10236 // If the base is a pointer, we don't have a way to get the size of the
10238 if (BaseQTy->isPointerType())
10241 // We can only check if the length is the same as the size of the dimension
10242 // if we have a constant array.
10243 auto *CATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr());
10247 llvm::APSInt ConstLength;
10248 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
10249 return false; // Can't get the integer value as a constant.
10251 return CATy->getSize().getSExtValue() != ConstLength.getSExtValue();
10254 // Return true if it can be proven that the provided array expression (array
10255 // section or array subscript) does NOT specify a single element of the array
10256 // whose base type is \a BaseQTy.
10257 static bool CheckArrayExpressionDoesNotReferToUnitySize(Sema &SemaRef,
10259 QualType BaseQTy) {
10260 auto *OASE = dyn_cast<OMPArraySectionExpr>(E);
10262 // An array subscript always refer to a single element. Also, an array section
10263 // assumes the format of an array subscript if no colon is used.
10264 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid()))
10267 assert(OASE && "Expecting array section if not an array subscript.");
10268 auto *Length = OASE->getLength();
10270 // If we don't have a length we have to check if the array has unitary size
10271 // for this dimension. Also, we should always expect a length if the base type
10274 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()))
10275 return ATy->getSize().getSExtValue() != 1;
10276 // We cannot assume anything.
10280 // Check if the length evaluates to 1.
10281 llvm::APSInt ConstLength;
10282 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
10283 return false; // Can't get the integer value as a constant.
10285 return ConstLength.getSExtValue() != 1;
10288 // Return the expression of the base of the mappable expression or null if it
10289 // cannot be determined and do all the necessary checks to see if the expression
10290 // is valid as a standalone mappable expression. In the process, record all the
10291 // components of the expression.
10292 static Expr *CheckMapClauseExpressionBase(
10293 Sema &SemaRef, Expr *E,
10294 OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents,
10295 OpenMPClauseKind CKind) {
10296 SourceLocation ELoc = E->getExprLoc();
10297 SourceRange ERange = E->getSourceRange();
10299 // The base of elements of list in a map clause have to be either:
10300 // - a reference to variable or field.
10301 // - a member expression.
10302 // - an array expression.
10304 // E.g. if we have the expression 'r.S.Arr[:12]', we want to retrieve the
10305 // reference to 'r'.
10312 // #pragma omp target map (S.Arr[:12]);
10316 // We want to retrieve the member expression 'this->S';
10318 Expr *RelevantExpr = nullptr;
10320 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.2]
10321 // If a list item is an array section, it must specify contiguous storage.
10323 // For this restriction it is sufficient that we make sure only references
10324 // to variables or fields and array expressions, and that no array sections
10325 // exist except in the rightmost expression (unless they cover the whole
10326 // dimension of the array). E.g. these would be invalid:
10328 // r.ArrS[3:5].Arr[6:7]
10332 // but these would be valid:
10333 // r.ArrS[3].Arr[6:7]
10337 bool AllowUnitySizeArraySection = true;
10338 bool AllowWholeSizeArraySection = true;
10340 while (!RelevantExpr) {
10341 E = E->IgnoreParenImpCasts();
10343 if (auto *CurE = dyn_cast<DeclRefExpr>(E)) {
10344 if (!isa<VarDecl>(CurE->getDecl()))
10347 RelevantExpr = CurE;
10349 // If we got a reference to a declaration, we should not expect any array
10350 // section before that.
10351 AllowUnitySizeArraySection = false;
10352 AllowWholeSizeArraySection = false;
10354 // Record the component.
10355 CurComponents.push_back(OMPClauseMappableExprCommon::MappableComponent(
10356 CurE, CurE->getDecl()));
10360 if (auto *CurE = dyn_cast<MemberExpr>(E)) {
10361 auto *BaseE = CurE->getBase()->IgnoreParenImpCasts();
10363 if (isa<CXXThisExpr>(BaseE))
10364 // We found a base expression: this->Val.
10365 RelevantExpr = CurE;
10369 if (!isa<FieldDecl>(CurE->getMemberDecl())) {
10370 SemaRef.Diag(ELoc, diag::err_omp_expected_access_to_data_field)
10371 << CurE->getSourceRange();
10375 auto *FD = cast<FieldDecl>(CurE->getMemberDecl());
10377 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3]
10378 // A bit-field cannot appear in a map clause.
10380 if (FD->isBitField()) {
10381 SemaRef.Diag(ELoc, diag::err_omp_bit_fields_forbidden_in_clause)
10382 << CurE->getSourceRange() << getOpenMPClauseName(CKind);
10386 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10387 // If the type of a list item is a reference to a type T then the type
10388 // will be considered to be T for all purposes of this clause.
10389 QualType CurType = BaseE->getType().getNonReferenceType();
10391 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.2]
10392 // A list item cannot be a variable that is a member of a structure with
10395 if (auto *RT = CurType->getAs<RecordType>())
10396 if (RT->isUnionType()) {
10397 SemaRef.Diag(ELoc, diag::err_omp_union_type_not_allowed)
10398 << CurE->getSourceRange();
10402 // If we got a member expression, we should not expect any array section
10405 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7]
10406 // If a list item is an element of a structure, only the rightmost symbol
10407 // of the variable reference can be an array section.
10409 AllowUnitySizeArraySection = false;
10410 AllowWholeSizeArraySection = false;
10412 // Record the component.
10413 CurComponents.push_back(
10414 OMPClauseMappableExprCommon::MappableComponent(CurE, FD));
10418 if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) {
10419 E = CurE->getBase()->IgnoreParenImpCasts();
10421 if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) {
10422 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
10423 << 0 << CurE->getSourceRange();
10427 // If we got an array subscript that express the whole dimension we
10428 // can have any array expressions before. If it only expressing part of
10429 // the dimension, we can only have unitary-size array expressions.
10430 if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE,
10432 AllowWholeSizeArraySection = false;
10434 // Record the component - we don't have any declaration associated.
10435 CurComponents.push_back(
10436 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
10440 if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) {
10441 E = CurE->getBase()->IgnoreParenImpCasts();
10444 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
10446 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10447 // If the type of a list item is a reference to a type T then the type
10448 // will be considered to be T for all purposes of this clause.
10449 if (CurType->isReferenceType())
10450 CurType = CurType->getPointeeType();
10452 bool IsPointer = CurType->isAnyPointerType();
10454 if (!IsPointer && !CurType->isArrayType()) {
10455 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name)
10456 << 0 << CurE->getSourceRange();
10461 CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, CurType);
10463 CheckArrayExpressionDoesNotReferToUnitySize(SemaRef, CurE, CurType);
10465 if (AllowWholeSizeArraySection) {
10466 // Any array section is currently allowed. Allowing a whole size array
10467 // section implies allowing a unity array section as well.
10469 // If this array section refers to the whole dimension we can still
10470 // accept other array sections before this one, except if the base is a
10471 // pointer. Otherwise, only unitary sections are accepted.
10472 if (NotWhole || IsPointer)
10473 AllowWholeSizeArraySection = false;
10474 } else if (AllowUnitySizeArraySection && NotUnity) {
10475 // A unity or whole array section is not allowed and that is not
10476 // compatible with the properties of the current array section.
10478 ELoc, diag::err_array_section_does_not_specify_contiguous_storage)
10479 << CurE->getSourceRange();
10483 // Record the component - we don't have any declaration associated.
10484 CurComponents.push_back(
10485 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr));
10489 // If nothing else worked, this is not a valid map clause expression.
10491 diag::err_omp_expected_named_var_member_or_array_expression)
10496 return RelevantExpr;
10499 // Return true if expression E associated with value VD has conflicts with other
10500 // map information.
10501 static bool CheckMapConflicts(
10502 Sema &SemaRef, DSAStackTy *DSAS, ValueDecl *VD, Expr *E,
10503 bool CurrentRegionOnly,
10504 OMPClauseMappableExprCommon::MappableExprComponentListRef CurComponents,
10505 OpenMPClauseKind CKind) {
10507 SourceLocation ELoc = E->getExprLoc();
10508 SourceRange ERange = E->getSourceRange();
10510 // In order to easily check the conflicts we need to match each component of
10511 // the expression under test with the components of the expressions that are
10512 // already in the stack.
10514 assert(!CurComponents.empty() && "Map clause expression with no components!");
10515 assert(CurComponents.back().getAssociatedDeclaration() == VD &&
10516 "Map clause expression with unexpected base!");
10518 // Variables to help detecting enclosing problems in data environment nests.
10519 bool IsEnclosedByDataEnvironmentExpr = false;
10520 const Expr *EnclosingExpr = nullptr;
10522 bool FoundError = DSAS->checkMappableExprComponentListsForDecl(
10523 VD, CurrentRegionOnly,
10524 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
10526 OpenMPClauseKind) -> bool {
10528 assert(!StackComponents.empty() &&
10529 "Map clause expression with no components!");
10530 assert(StackComponents.back().getAssociatedDeclaration() == VD &&
10531 "Map clause expression with unexpected base!");
10533 // The whole expression in the stack.
10534 auto *RE = StackComponents.front().getAssociatedExpression();
10536 // Expressions must start from the same base. Here we detect at which
10537 // point both expressions diverge from each other and see if we can
10538 // detect if the memory referred to both expressions is contiguous and
10540 auto CI = CurComponents.rbegin();
10541 auto CE = CurComponents.rend();
10542 auto SI = StackComponents.rbegin();
10543 auto SE = StackComponents.rend();
10544 for (; CI != CE && SI != SE; ++CI, ++SI) {
10546 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.3]
10547 // At most one list item can be an array item derived from a given
10548 // variable in map clauses of the same construct.
10549 if (CurrentRegionOnly &&
10550 (isa<ArraySubscriptExpr>(CI->getAssociatedExpression()) ||
10551 isa<OMPArraySectionExpr>(CI->getAssociatedExpression())) &&
10552 (isa<ArraySubscriptExpr>(SI->getAssociatedExpression()) ||
10553 isa<OMPArraySectionExpr>(SI->getAssociatedExpression()))) {
10554 SemaRef.Diag(CI->getAssociatedExpression()->getExprLoc(),
10555 diag::err_omp_multiple_array_items_in_map_clause)
10556 << CI->getAssociatedExpression()->getSourceRange();
10557 SemaRef.Diag(SI->getAssociatedExpression()->getExprLoc(),
10558 diag::note_used_here)
10559 << SI->getAssociatedExpression()->getSourceRange();
10563 // Do both expressions have the same kind?
10564 if (CI->getAssociatedExpression()->getStmtClass() !=
10565 SI->getAssociatedExpression()->getStmtClass())
10568 // Are we dealing with different variables/fields?
10569 if (CI->getAssociatedDeclaration() != SI->getAssociatedDeclaration())
10572 // Check if the extra components of the expressions in the enclosing
10573 // data environment are redundant for the current base declaration.
10574 // If they are, the maps completely overlap, which is legal.
10575 for (; SI != SE; ++SI) {
10578 dyn_cast<ArraySubscriptExpr>(SI->getAssociatedExpression())) {
10579 Type = ASE->getBase()->IgnoreParenImpCasts()->getType();
10580 } else if (auto *OASE = dyn_cast<OMPArraySectionExpr>(
10581 SI->getAssociatedExpression())) {
10582 auto *E = OASE->getBase()->IgnoreParenImpCasts();
10584 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType();
10586 if (Type.isNull() || Type->isAnyPointerType() ||
10587 CheckArrayExpressionDoesNotReferToWholeSize(
10588 SemaRef, SI->getAssociatedExpression(), Type))
10592 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10593 // List items of map clauses in the same construct must not share
10594 // original storage.
10596 // If the expressions are exactly the same or one is a subset of the
10597 // other, it means they are sharing storage.
10598 if (CI == CE && SI == SE) {
10599 if (CurrentRegionOnly) {
10600 if (CKind == OMPC_map)
10601 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10603 assert(CKind == OMPC_to || CKind == OMPC_from);
10604 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10607 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10608 << RE->getSourceRange();
10611 // If we find the same expression in the enclosing data environment,
10613 IsEnclosedByDataEnvironmentExpr = true;
10618 QualType DerivedType =
10619 std::prev(CI)->getAssociatedDeclaration()->getType();
10620 SourceLocation DerivedLoc =
10621 std::prev(CI)->getAssociatedExpression()->getExprLoc();
10623 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10624 // If the type of a list item is a reference to a type T then the type
10625 // will be considered to be T for all purposes of this clause.
10626 DerivedType = DerivedType.getNonReferenceType();
10628 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.1]
10629 // A variable for which the type is pointer and an array section
10630 // derived from that variable must not appear as list items of map
10631 // clauses of the same construct.
10633 // Also, cover one of the cases in:
10634 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10635 // If any part of the original storage of a list item has corresponding
10636 // storage in the device data environment, all of the original storage
10637 // must have corresponding storage in the device data environment.
10639 if (DerivedType->isAnyPointerType()) {
10640 if (CI == CE || SI == SE) {
10643 diag::err_omp_pointer_mapped_along_with_derived_section)
10646 assert(CI != CE && SI != SE);
10647 SemaRef.Diag(DerivedLoc, diag::err_omp_same_pointer_derreferenced)
10650 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10651 << RE->getSourceRange();
10655 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4]
10656 // List items of map clauses in the same construct must not share
10657 // original storage.
10659 // An expression is a subset of the other.
10660 if (CurrentRegionOnly && (CI == CE || SI == SE)) {
10661 if (CKind == OMPC_map)
10662 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange;
10664 assert(CKind == OMPC_to || CKind == OMPC_from);
10665 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update)
10668 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here)
10669 << RE->getSourceRange();
10673 // The current expression uses the same base as other expression in the
10674 // data environment but does not contain it completely.
10675 if (!CurrentRegionOnly && SI != SE)
10676 EnclosingExpr = RE;
10678 // The current expression is a subset of the expression in the data
10680 IsEnclosedByDataEnvironmentExpr |=
10681 (!CurrentRegionOnly && CI != CE && SI == SE);
10686 if (CurrentRegionOnly)
10689 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5]
10690 // If any part of the original storage of a list item has corresponding
10691 // storage in the device data environment, all of the original storage must
10692 // have corresponding storage in the device data environment.
10693 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.6]
10694 // If a list item is an element of a structure, and a different element of
10695 // the structure has a corresponding list item in the device data environment
10696 // prior to a task encountering the construct associated with the map clause,
10697 // then the list item must also have a corresponding list item in the device
10698 // data environment prior to the task encountering the construct.
10700 if (EnclosingExpr && !IsEnclosedByDataEnvironmentExpr) {
10702 diag::err_omp_original_storage_is_shared_and_does_not_contain)
10704 SemaRef.Diag(EnclosingExpr->getExprLoc(), diag::note_used_here)
10705 << EnclosingExpr->getSourceRange();
10713 // Utility struct that gathers all the related lists associated with a mappable
10715 struct MappableVarListInfo final {
10716 // The list of expressions.
10717 ArrayRef<Expr *> VarList;
10718 // The list of processed expressions.
10719 SmallVector<Expr *, 16> ProcessedVarList;
10720 // The mappble components for each expression.
10721 OMPClauseMappableExprCommon::MappableExprComponentLists VarComponents;
10722 // The base declaration of the variable.
10723 SmallVector<ValueDecl *, 16> VarBaseDeclarations;
10725 MappableVarListInfo(ArrayRef<Expr *> VarList) : VarList(VarList) {
10726 // We have a list of components and base declarations for each entry in the
10728 VarComponents.reserve(VarList.size());
10729 VarBaseDeclarations.reserve(VarList.size());
10734 // Check the validity of the provided variable list for the provided clause kind
10735 // \a CKind. In the check process the valid expressions, and mappable expression
10736 // components and variables are extracted and used to fill \a Vars,
10737 // \a ClauseComponents, and \a ClauseBaseDeclarations. \a MapType and
10738 // \a IsMapTypeImplicit are expected to be valid if the clause kind is 'map'.
10740 checkMappableExpressionList(Sema &SemaRef, DSAStackTy *DSAS,
10741 OpenMPClauseKind CKind, MappableVarListInfo &MVLI,
10742 SourceLocation StartLoc,
10743 OpenMPMapClauseKind MapType = OMPC_MAP_unknown,
10744 bool IsMapTypeImplicit = false) {
10745 // We only expect mappable expressions in 'to', 'from', and 'map' clauses.
10746 assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from) &&
10747 "Unexpected clause kind with mappable expressions!");
10749 // Keep track of the mappable components and base declarations in this clause.
10750 // Each entry in the list is going to have a list of components associated. We
10751 // record each set of the components so that we can build the clause later on.
10752 // In the end we should have the same amount of declarations and component
10755 for (auto &RE : MVLI.VarList) {
10756 assert(RE && "Null expr in omp to/from/map clause");
10757 SourceLocation ELoc = RE->getExprLoc();
10759 auto *VE = RE->IgnoreParenLValueCasts();
10761 if (VE->isValueDependent() || VE->isTypeDependent() ||
10762 VE->isInstantiationDependent() ||
10763 VE->containsUnexpandedParameterPack()) {
10764 // We can only analyze this information once the missing information is
10766 MVLI.ProcessedVarList.push_back(RE);
10770 auto *SimpleExpr = RE->IgnoreParenCasts();
10772 if (!RE->IgnoreParenImpCasts()->isLValue()) {
10774 diag::err_omp_expected_named_var_member_or_array_expression)
10775 << RE->getSourceRange();
10779 OMPClauseMappableExprCommon::MappableExprComponentList CurComponents;
10780 ValueDecl *CurDeclaration = nullptr;
10782 // Obtain the array or member expression bases if required. Also, fill the
10783 // components array with all the components identified in the process.
10785 CheckMapClauseExpressionBase(SemaRef, SimpleExpr, CurComponents, CKind);
10789 assert(!CurComponents.empty() &&
10790 "Invalid mappable expression information.");
10792 // For the following checks, we rely on the base declaration which is
10793 // expected to be associated with the last component. The declaration is
10794 // expected to be a variable or a field (if 'this' is being mapped).
10795 CurDeclaration = CurComponents.back().getAssociatedDeclaration();
10796 assert(CurDeclaration && "Null decl on map clause.");
10798 CurDeclaration->isCanonicalDecl() &&
10799 "Expecting components to have associated only canonical declarations.");
10801 auto *VD = dyn_cast<VarDecl>(CurDeclaration);
10802 auto *FD = dyn_cast<FieldDecl>(CurDeclaration);
10804 assert((VD || FD) && "Only variables or fields are expected here!");
10807 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.10]
10808 // threadprivate variables cannot appear in a map clause.
10809 // OpenMP 4.5 [2.10.5, target update Construct]
10810 // threadprivate variables cannot appear in a from clause.
10811 if (VD && DSAS->isThreadPrivate(VD)) {
10812 auto DVar = DSAS->getTopDSA(VD, false);
10813 SemaRef.Diag(ELoc, diag::err_omp_threadprivate_in_clause)
10814 << getOpenMPClauseName(CKind);
10815 ReportOriginalDSA(SemaRef, DSAS, VD, DVar);
10819 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10820 // A list item cannot appear in both a map clause and a data-sharing
10821 // attribute clause on the same construct.
10823 // Check conflicts with other map clause expressions. We check the conflicts
10824 // with the current construct separately from the enclosing data
10825 // environment, because the restrictions are different. We only have to
10826 // check conflicts across regions for the map clauses.
10827 if (CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10828 /*CurrentRegionOnly=*/true, CurComponents, CKind))
10830 if (CKind == OMPC_map &&
10831 CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr,
10832 /*CurrentRegionOnly=*/false, CurComponents, CKind))
10835 // OpenMP 4.5 [2.10.5, target update Construct]
10836 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1]
10837 // If the type of a list item is a reference to a type T then the type will
10838 // be considered to be T for all purposes of this clause.
10839 QualType Type = CurDeclaration->getType().getNonReferenceType();
10841 // OpenMP 4.5 [2.10.5, target update Construct, Restrictions, p.4]
10842 // A list item in a to or from clause must have a mappable type.
10843 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9]
10844 // A list item must have a mappable type.
10845 if (!CheckTypeMappable(VE->getExprLoc(), VE->getSourceRange(), SemaRef,
10849 if (CKind == OMPC_map) {
10850 // target enter data
10851 // OpenMP [2.10.2, Restrictions, p. 99]
10852 // A map-type must be specified in all map clauses and must be either
10854 OpenMPDirectiveKind DKind = DSAS->getCurrentDirective();
10855 if (DKind == OMPD_target_enter_data &&
10856 !(MapType == OMPC_MAP_to || MapType == OMPC_MAP_alloc)) {
10857 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10858 << (IsMapTypeImplicit ? 1 : 0)
10859 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10860 << getOpenMPDirectiveName(DKind);
10864 // target exit_data
10865 // OpenMP [2.10.3, Restrictions, p. 102]
10866 // A map-type must be specified in all map clauses and must be either
10867 // from, release, or delete.
10868 if (DKind == OMPD_target_exit_data &&
10869 !(MapType == OMPC_MAP_from || MapType == OMPC_MAP_release ||
10870 MapType == OMPC_MAP_delete)) {
10871 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive)
10872 << (IsMapTypeImplicit ? 1 : 0)
10873 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType)
10874 << getOpenMPDirectiveName(DKind);
10878 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
10879 // A list item cannot appear in both a map clause and a data-sharing
10880 // attribute clause on the same construct
10881 if ((DKind == OMPD_target || DKind == OMPD_target_teams ||
10882 DKind == OMPD_target_teams_distribute ||
10883 DKind == OMPD_target_teams_distribute_parallel_for ||
10884 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
10885 DKind == OMPD_target_teams_distribute_simd) && VD) {
10886 auto DVar = DSAS->getTopDSA(VD, false);
10887 if (isOpenMPPrivate(DVar.CKind)) {
10888 SemaRef.Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
10889 << getOpenMPClauseName(DVar.CKind)
10890 << getOpenMPClauseName(OMPC_map)
10891 << getOpenMPDirectiveName(DSAS->getCurrentDirective());
10892 ReportOriginalDSA(SemaRef, DSAS, CurDeclaration, DVar);
10898 // Save the current expression.
10899 MVLI.ProcessedVarList.push_back(RE);
10901 // Store the components in the stack so that they can be used to check
10902 // against other clauses later on.
10903 DSAS->addMappableExpressionComponents(CurDeclaration, CurComponents,
10904 /*WhereFoundClauseKind=*/OMPC_map);
10906 // Save the components and declaration to create the clause. For purposes of
10907 // the clause creation, any component list that has has base 'this' uses
10908 // null as base declaration.
10909 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
10910 MVLI.VarComponents.back().append(CurComponents.begin(),
10911 CurComponents.end());
10912 MVLI.VarBaseDeclarations.push_back(isa<MemberExpr>(BE) ? nullptr
10918 Sema::ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,
10919 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
10920 SourceLocation MapLoc, SourceLocation ColonLoc,
10921 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
10922 SourceLocation LParenLoc, SourceLocation EndLoc) {
10923 MappableVarListInfo MVLI(VarList);
10924 checkMappableExpressionList(*this, DSAStack, OMPC_map, MVLI, StartLoc,
10925 MapType, IsMapTypeImplicit);
10927 // We need to produce a map clause even if we don't have variables so that
10928 // other diagnostics related with non-existing map clauses are accurate.
10929 return OMPMapClause::Create(Context, StartLoc, LParenLoc, EndLoc,
10930 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
10931 MVLI.VarComponents, MapTypeModifier, MapType,
10932 IsMapTypeImplicit, MapLoc);
10935 QualType Sema::ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
10936 TypeResult ParsedType) {
10937 assert(ParsedType.isUsable());
10939 QualType ReductionType = GetTypeFromParser(ParsedType.get());
10940 if (ReductionType.isNull())
10943 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions, C\C++
10944 // A type name in a declare reduction directive cannot be a function type, an
10945 // array type, a reference type, or a type qualified with const, volatile or
10947 if (ReductionType.hasQualifiers()) {
10948 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 0;
10952 if (ReductionType->isFunctionType()) {
10953 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 1;
10956 if (ReductionType->isReferenceType()) {
10957 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 2;
10960 if (ReductionType->isArrayType()) {
10961 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 3;
10964 return ReductionType;
10967 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveStart(
10968 Scope *S, DeclContext *DC, DeclarationName Name,
10969 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
10970 AccessSpecifier AS, Decl *PrevDeclInScope) {
10971 SmallVector<Decl *, 8> Decls;
10972 Decls.reserve(ReductionTypes.size());
10974 LookupResult Lookup(*this, Name, SourceLocation(), LookupOMPReductionName,
10976 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
10977 // A reduction-identifier may not be re-declared in the current scope for the
10978 // same type or for a type that is compatible according to the base language
10980 llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
10981 OMPDeclareReductionDecl *PrevDRD = nullptr;
10982 bool InCompoundScope = true;
10983 if (S != nullptr) {
10984 // Find previous declaration with the same name not referenced in other
10986 FunctionScopeInfo *ParentFn = getEnclosingFunction();
10988 (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty();
10989 LookupName(Lookup, S);
10990 FilterLookupForScope(Lookup, DC, S, /*ConsiderLinkage=*/false,
10991 /*AllowInlineNamespace=*/false);
10992 llvm::DenseMap<OMPDeclareReductionDecl *, bool> UsedAsPrevious;
10993 auto Filter = Lookup.makeFilter();
10994 while (Filter.hasNext()) {
10995 auto *PrevDecl = cast<OMPDeclareReductionDecl>(Filter.next());
10996 if (InCompoundScope) {
10997 auto I = UsedAsPrevious.find(PrevDecl);
10998 if (I == UsedAsPrevious.end())
10999 UsedAsPrevious[PrevDecl] = false;
11000 if (auto *D = PrevDecl->getPrevDeclInScope())
11001 UsedAsPrevious[D] = true;
11003 PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] =
11004 PrevDecl->getLocation();
11007 if (InCompoundScope) {
11008 for (auto &PrevData : UsedAsPrevious) {
11009 if (!PrevData.second) {
11010 PrevDRD = PrevData.first;
11015 } else if (PrevDeclInScope != nullptr) {
11016 auto *PrevDRDInScope = PrevDRD =
11017 cast<OMPDeclareReductionDecl>(PrevDeclInScope);
11019 PreviousRedeclTypes[PrevDRDInScope->getType().getCanonicalType()] =
11020 PrevDRDInScope->getLocation();
11021 PrevDRDInScope = PrevDRDInScope->getPrevDeclInScope();
11022 } while (PrevDRDInScope != nullptr);
11024 for (auto &TyData : ReductionTypes) {
11025 auto I = PreviousRedeclTypes.find(TyData.first.getCanonicalType());
11026 bool Invalid = false;
11027 if (I != PreviousRedeclTypes.end()) {
11028 Diag(TyData.second, diag::err_omp_declare_reduction_redefinition)
11030 Diag(I->second, diag::note_previous_definition);
11033 PreviousRedeclTypes[TyData.first.getCanonicalType()] = TyData.second;
11034 auto *DRD = OMPDeclareReductionDecl::Create(Context, DC, TyData.second,
11035 Name, TyData.first, PrevDRD);
11037 DRD->setAccess(AS);
11038 Decls.push_back(DRD);
11040 DRD->setInvalidDecl();
11045 return DeclGroupPtrTy::make(
11046 DeclGroupRef::Create(Context, Decls.begin(), Decls.size()));
11049 void Sema::ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D) {
11050 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11052 // Enter new function scope.
11053 PushFunctionScope();
11054 getCurFunction()->setHasBranchProtectedScope();
11055 getCurFunction()->setHasOMPDeclareReductionCombiner();
11058 PushDeclContext(S, DRD);
11062 PushExpressionEvaluationContext(
11063 ExpressionEvaluationContext::PotentiallyEvaluated);
11065 QualType ReductionType = DRD->getType();
11066 // Create 'T* omp_parm;T omp_in;'. All references to 'omp_in' will
11067 // be replaced by '*omp_parm' during codegen. This required because 'omp_in'
11068 // uses semantics of argument handles by value, but it should be passed by
11069 // reference. C lang does not support references, so pass all parameters as
11071 // Create 'T omp_in;' variable.
11073 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_in");
11074 // Create 'T* omp_parm;T omp_out;'. All references to 'omp_out' will
11075 // be replaced by '*omp_parm' during codegen. This required because 'omp_out'
11076 // uses semantics of argument handles by value, but it should be passed by
11077 // reference. C lang does not support references, so pass all parameters as
11079 // Create 'T omp_out;' variable.
11081 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_out");
11082 if (S != nullptr) {
11083 PushOnScopeChains(OmpInParm, S);
11084 PushOnScopeChains(OmpOutParm, S);
11086 DRD->addDecl(OmpInParm);
11087 DRD->addDecl(OmpOutParm);
11091 void Sema::ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner) {
11092 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11093 DiscardCleanupsInEvaluationContext();
11094 PopExpressionEvaluationContext();
11097 PopFunctionScopeInfo();
11099 if (Combiner != nullptr)
11100 DRD->setCombiner(Combiner);
11102 DRD->setInvalidDecl();
11105 void Sema::ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D) {
11106 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11108 // Enter new function scope.
11109 PushFunctionScope();
11110 getCurFunction()->setHasBranchProtectedScope();
11113 PushDeclContext(S, DRD);
11117 PushExpressionEvaluationContext(
11118 ExpressionEvaluationContext::PotentiallyEvaluated);
11120 QualType ReductionType = DRD->getType();
11121 // Create 'T* omp_parm;T omp_priv;'. All references to 'omp_priv' will
11122 // be replaced by '*omp_parm' during codegen. This required because 'omp_priv'
11123 // uses semantics of argument handles by value, but it should be passed by
11124 // reference. C lang does not support references, so pass all parameters as
11126 // Create 'T omp_priv;' variable.
11127 auto *OmpPrivParm =
11128 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_priv");
11129 // Create 'T* omp_parm;T omp_orig;'. All references to 'omp_orig' will
11130 // be replaced by '*omp_parm' during codegen. This required because 'omp_orig'
11131 // uses semantics of argument handles by value, but it should be passed by
11132 // reference. C lang does not support references, so pass all parameters as
11134 // Create 'T omp_orig;' variable.
11135 auto *OmpOrigParm =
11136 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_orig");
11137 if (S != nullptr) {
11138 PushOnScopeChains(OmpPrivParm, S);
11139 PushOnScopeChains(OmpOrigParm, S);
11141 DRD->addDecl(OmpPrivParm);
11142 DRD->addDecl(OmpOrigParm);
11146 void Sema::ActOnOpenMPDeclareReductionInitializerEnd(Decl *D,
11147 Expr *Initializer) {
11148 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11149 DiscardCleanupsInEvaluationContext();
11150 PopExpressionEvaluationContext();
11153 PopFunctionScopeInfo();
11155 if (Initializer != nullptr)
11156 DRD->setInitializer(Initializer);
11158 DRD->setInvalidDecl();
11161 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveEnd(
11162 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid) {
11163 for (auto *D : DeclReductions.get()) {
11165 auto *DRD = cast<OMPDeclareReductionDecl>(D);
11167 PushOnScopeChains(DRD, S, /*AddToContext=*/false);
11169 D->setInvalidDecl();
11171 return DeclReductions;
11174 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams,
11175 SourceLocation StartLoc,
11176 SourceLocation LParenLoc,
11177 SourceLocation EndLoc) {
11178 Expr *ValExpr = NumTeams;
11179 Stmt *HelperValStmt = nullptr;
11180 OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
11182 // OpenMP [teams Constrcut, Restrictions]
11183 // The num_teams expression must evaluate to a positive integer value.
11184 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_teams,
11185 /*StrictlyPositive=*/true))
11188 OpenMPDirectiveKind DKind = DSAStack->getCurrentDirective();
11189 CaptureRegion = getOpenMPCaptureRegionForClause(DKind, OMPC_num_teams);
11190 if (CaptureRegion != OMPD_unknown) {
11191 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
11192 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
11193 HelperValStmt = buildPreInits(Context, Captures);
11196 return new (Context) OMPNumTeamsClause(ValExpr, HelperValStmt, CaptureRegion,
11197 StartLoc, LParenLoc, EndLoc);
11200 OMPClause *Sema::ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
11201 SourceLocation StartLoc,
11202 SourceLocation LParenLoc,
11203 SourceLocation EndLoc) {
11204 Expr *ValExpr = ThreadLimit;
11205 Stmt *HelperValStmt = nullptr;
11206 OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
11208 // OpenMP [teams Constrcut, Restrictions]
11209 // The thread_limit expression must evaluate to a positive integer value.
11210 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_thread_limit,
11211 /*StrictlyPositive=*/true))
11214 OpenMPDirectiveKind DKind = DSAStack->getCurrentDirective();
11215 CaptureRegion = getOpenMPCaptureRegionForClause(DKind, OMPC_thread_limit);
11216 if (CaptureRegion != OMPD_unknown) {
11217 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
11218 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
11219 HelperValStmt = buildPreInits(Context, Captures);
11222 return new (Context) OMPThreadLimitClause(
11223 ValExpr, HelperValStmt, CaptureRegion, StartLoc, LParenLoc, EndLoc);
11226 OMPClause *Sema::ActOnOpenMPPriorityClause(Expr *Priority,
11227 SourceLocation StartLoc,
11228 SourceLocation LParenLoc,
11229 SourceLocation EndLoc) {
11230 Expr *ValExpr = Priority;
11232 // OpenMP [2.9.1, task Constrcut]
11233 // The priority-value is a non-negative numerical scalar expression.
11234 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_priority,
11235 /*StrictlyPositive=*/false))
11238 return new (Context) OMPPriorityClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11241 OMPClause *Sema::ActOnOpenMPGrainsizeClause(Expr *Grainsize,
11242 SourceLocation StartLoc,
11243 SourceLocation LParenLoc,
11244 SourceLocation EndLoc) {
11245 Expr *ValExpr = Grainsize;
11247 // OpenMP [2.9.2, taskloop Constrcut]
11248 // The parameter of the grainsize clause must be a positive integer
11250 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_grainsize,
11251 /*StrictlyPositive=*/true))
11254 return new (Context) OMPGrainsizeClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11257 OMPClause *Sema::ActOnOpenMPNumTasksClause(Expr *NumTasks,
11258 SourceLocation StartLoc,
11259 SourceLocation LParenLoc,
11260 SourceLocation EndLoc) {
11261 Expr *ValExpr = NumTasks;
11263 // OpenMP [2.9.2, taskloop Constrcut]
11264 // The parameter of the num_tasks clause must be a positive integer
11266 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_tasks,
11267 /*StrictlyPositive=*/true))
11270 return new (Context) OMPNumTasksClause(ValExpr, StartLoc, LParenLoc, EndLoc);
11273 OMPClause *Sema::ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
11274 SourceLocation LParenLoc,
11275 SourceLocation EndLoc) {
11276 // OpenMP [2.13.2, critical construct, Description]
11277 // ... where hint-expression is an integer constant expression that evaluates
11278 // to a valid lock hint.
11279 ExprResult HintExpr = VerifyPositiveIntegerConstantInClause(Hint, OMPC_hint);
11280 if (HintExpr.isInvalid())
11282 return new (Context)
11283 OMPHintClause(HintExpr.get(), StartLoc, LParenLoc, EndLoc);
11286 OMPClause *Sema::ActOnOpenMPDistScheduleClause(
11287 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11288 SourceLocation LParenLoc, SourceLocation KindLoc, SourceLocation CommaLoc,
11289 SourceLocation EndLoc) {
11290 if (Kind == OMPC_DIST_SCHEDULE_unknown) {
11291 std::string Values;
11293 Values += getOpenMPSimpleClauseTypeName(OMPC_dist_schedule, 0);
11295 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
11296 << Values << getOpenMPClauseName(OMPC_dist_schedule);
11299 Expr *ValExpr = ChunkSize;
11300 Stmt *HelperValStmt = nullptr;
11302 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
11303 !ChunkSize->isInstantiationDependent() &&
11304 !ChunkSize->containsUnexpandedParameterPack()) {
11305 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
11307 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
11308 if (Val.isInvalid())
11311 ValExpr = Val.get();
11313 // OpenMP [2.7.1, Restrictions]
11314 // chunk_size must be a loop invariant integer expression with a positive
11316 llvm::APSInt Result;
11317 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
11318 if (Result.isSigned() && !Result.isStrictlyPositive()) {
11319 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
11320 << "dist_schedule" << ChunkSize->getSourceRange();
11323 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) &&
11324 !CurContext->isDependentContext()) {
11325 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
11326 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
11327 HelperValStmt = buildPreInits(Context, Captures);
11332 return new (Context)
11333 OMPDistScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc,
11334 Kind, ValExpr, HelperValStmt);
11337 OMPClause *Sema::ActOnOpenMPDefaultmapClause(
11338 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11339 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11340 SourceLocation KindLoc, SourceLocation EndLoc) {
11341 // OpenMP 4.5 only supports 'defaultmap(tofrom: scalar)'
11342 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom || Kind != OMPC_DEFAULTMAP_scalar) {
11344 SourceLocation Loc;
11346 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom) {
11347 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
11348 OMPC_DEFAULTMAP_MODIFIER_tofrom);
11351 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
11352 OMPC_DEFAULTMAP_scalar);
11356 Diag(Loc, diag::err_omp_unexpected_clause_value)
11357 << Value << getOpenMPClauseName(OMPC_defaultmap);
11361 return new (Context)
11362 OMPDefaultmapClause(StartLoc, LParenLoc, MLoc, KindLoc, EndLoc, Kind, M);
11365 bool Sema::ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc) {
11366 DeclContext *CurLexicalContext = getCurLexicalContext();
11367 if (!CurLexicalContext->isFileContext() &&
11368 !CurLexicalContext->isExternCContext() &&
11369 !CurLexicalContext->isExternCXXContext()) {
11370 Diag(Loc, diag::err_omp_region_not_file_context);
11373 if (IsInOpenMPDeclareTargetContext) {
11374 Diag(Loc, diag::err_omp_enclosed_declare_target);
11378 IsInOpenMPDeclareTargetContext = true;
11382 void Sema::ActOnFinishOpenMPDeclareTargetDirective() {
11383 assert(IsInOpenMPDeclareTargetContext &&
11384 "Unexpected ActOnFinishOpenMPDeclareTargetDirective");
11386 IsInOpenMPDeclareTargetContext = false;
11389 void Sema::ActOnOpenMPDeclareTargetName(Scope *CurScope,
11390 CXXScopeSpec &ScopeSpec,
11391 const DeclarationNameInfo &Id,
11392 OMPDeclareTargetDeclAttr::MapTypeTy MT,
11393 NamedDeclSetType &SameDirectiveDecls) {
11394 LookupResult Lookup(*this, Id, LookupOrdinaryName);
11395 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
11397 if (Lookup.isAmbiguous())
11399 Lookup.suppressDiagnostics();
11401 if (!Lookup.isSingleResult()) {
11402 if (TypoCorrection Corrected =
11403 CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr,
11404 llvm::make_unique<VarOrFuncDeclFilterCCC>(*this),
11405 CTK_ErrorRecovery)) {
11406 diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
11408 checkDeclIsAllowedInOpenMPTarget(nullptr, Corrected.getCorrectionDecl());
11412 Diag(Id.getLoc(), diag::err_undeclared_var_use) << Id.getName();
11416 NamedDecl *ND = Lookup.getAsSingle<NamedDecl>();
11417 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
11418 if (!SameDirectiveDecls.insert(cast<NamedDecl>(ND->getCanonicalDecl())))
11419 Diag(Id.getLoc(), diag::err_omp_declare_target_multiple) << Id.getName();
11421 if (!ND->hasAttr<OMPDeclareTargetDeclAttr>()) {
11422 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(Context, MT);
11424 if (ASTMutationListener *ML = Context.getASTMutationListener())
11425 ML->DeclarationMarkedOpenMPDeclareTarget(ND, A);
11426 checkDeclIsAllowedInOpenMPTarget(nullptr, ND);
11427 } else if (ND->getAttr<OMPDeclareTargetDeclAttr>()->getMapType() != MT) {
11428 Diag(Id.getLoc(), diag::err_omp_declare_target_to_and_link)
11432 Diag(Id.getLoc(), diag::err_omp_invalid_target_decl) << Id.getName();
11435 static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR,
11436 Sema &SemaRef, Decl *D) {
11439 Decl *LD = nullptr;
11440 if (isa<TagDecl>(D)) {
11441 LD = cast<TagDecl>(D)->getDefinition();
11442 } else if (isa<VarDecl>(D)) {
11443 LD = cast<VarDecl>(D)->getDefinition();
11445 // If this is an implicit variable that is legal and we do not need to do
11447 if (cast<VarDecl>(D)->isImplicit()) {
11448 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11449 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11451 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11452 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11456 } else if (isa<FunctionDecl>(D)) {
11457 const FunctionDecl *FD = nullptr;
11458 if (cast<FunctionDecl>(D)->hasBody(FD))
11459 LD = const_cast<FunctionDecl *>(FD);
11461 // If the definition is associated with the current declaration in the
11462 // target region (it can be e.g. a lambda) that is legal and we do not need
11463 // to do anything else.
11465 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11466 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11468 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11469 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11475 if (LD && !LD->hasAttr<OMPDeclareTargetDeclAttr>() &&
11476 (isa<VarDecl>(LD) || isa<FunctionDecl>(LD))) {
11477 // Outlined declaration is not declared target.
11478 if (LD->isOutOfLine()) {
11479 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
11480 SemaRef.Diag(SL, diag::note_used_here) << SR;
11482 DeclContext *DC = LD->getDeclContext();
11484 if (isa<FunctionDecl>(DC) &&
11485 cast<FunctionDecl>(DC)->hasAttr<OMPDeclareTargetDeclAttr>())
11487 DC = DC->getParent();
11492 // Is not declared in target context.
11493 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
11494 SemaRef.Diag(SL, diag::note_used_here) << SR;
11496 // Mark decl as declared target to prevent further diagnostic.
11497 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11498 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To);
11500 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener())
11501 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11505 static bool checkValueDeclInTarget(SourceLocation SL, SourceRange SR,
11506 Sema &SemaRef, DSAStackTy *Stack,
11508 if (VD->hasAttr<OMPDeclareTargetDeclAttr>())
11510 if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType()))
11515 void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) {
11516 if (!D || D->isInvalidDecl())
11518 SourceRange SR = E ? E->getSourceRange() : D->getSourceRange();
11519 SourceLocation SL = E ? E->getLocStart() : D->getLocation();
11520 // 2.10.6: threadprivate variable cannot appear in a declare target directive.
11521 if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
11522 if (DSAStack->isThreadPrivate(VD)) {
11523 Diag(SL, diag::err_omp_threadprivate_in_target);
11524 ReportOriginalDSA(*this, DSAStack, VD, DSAStack->getTopDSA(VD, false));
11528 if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
11529 // Problem if any with var declared with incomplete type will be reported
11530 // as normal, so no need to check it here.
11531 if ((E || !VD->getType()->isIncompleteType()) &&
11532 !checkValueDeclInTarget(SL, SR, *this, DSAStack, VD)) {
11533 // Mark decl as declared target to prevent further diagnostic.
11534 if (isa<VarDecl>(VD) || isa<FunctionDecl>(VD)) {
11535 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11536 Context, OMPDeclareTargetDeclAttr::MT_To);
11538 if (ASTMutationListener *ML = Context.getASTMutationListener())
11539 ML->DeclarationMarkedOpenMPDeclareTarget(VD, A);
11545 // Checking declaration inside declare target region.
11546 if (!D->hasAttr<OMPDeclareTargetDeclAttr>() &&
11547 (isa<VarDecl>(D) || isa<FunctionDecl>(D))) {
11548 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(
11549 Context, OMPDeclareTargetDeclAttr::MT_To);
11551 if (ASTMutationListener *ML = Context.getASTMutationListener())
11552 ML->DeclarationMarkedOpenMPDeclareTarget(D, A);
11556 checkDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this, D);
11559 OMPClause *Sema::ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
11560 SourceLocation StartLoc,
11561 SourceLocation LParenLoc,
11562 SourceLocation EndLoc) {
11563 MappableVarListInfo MVLI(VarList);
11564 checkMappableExpressionList(*this, DSAStack, OMPC_to, MVLI, StartLoc);
11565 if (MVLI.ProcessedVarList.empty())
11568 return OMPToClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11569 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11570 MVLI.VarComponents);
11573 OMPClause *Sema::ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
11574 SourceLocation StartLoc,
11575 SourceLocation LParenLoc,
11576 SourceLocation EndLoc) {
11577 MappableVarListInfo MVLI(VarList);
11578 checkMappableExpressionList(*this, DSAStack, OMPC_from, MVLI, StartLoc);
11579 if (MVLI.ProcessedVarList.empty())
11582 return OMPFromClause::Create(Context, StartLoc, LParenLoc, EndLoc,
11583 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations,
11584 MVLI.VarComponents);
11587 OMPClause *Sema::ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
11588 SourceLocation StartLoc,
11589 SourceLocation LParenLoc,
11590 SourceLocation EndLoc) {
11591 MappableVarListInfo MVLI(VarList);
11592 SmallVector<Expr *, 8> PrivateCopies;
11593 SmallVector<Expr *, 8> Inits;
11595 for (auto &RefExpr : VarList) {
11596 assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause.");
11597 SourceLocation ELoc;
11598 SourceRange ERange;
11599 Expr *SimpleRefExpr = RefExpr;
11600 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11602 // It will be analyzed later.
11603 MVLI.ProcessedVarList.push_back(RefExpr);
11604 PrivateCopies.push_back(nullptr);
11605 Inits.push_back(nullptr);
11607 ValueDecl *D = Res.first;
11611 QualType Type = D->getType();
11612 Type = Type.getNonReferenceType().getUnqualifiedType();
11614 auto *VD = dyn_cast<VarDecl>(D);
11616 // Item should be a pointer or reference to pointer.
11617 if (!Type->isPointerType()) {
11618 Diag(ELoc, diag::err_omp_usedeviceptr_not_a_pointer)
11619 << 0 << RefExpr->getSourceRange();
11623 // Build the private variable and the expression that refers to it.
11624 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
11625 D->hasAttrs() ? &D->getAttrs() : nullptr);
11626 if (VDPrivate->isInvalidDecl())
11629 CurContext->addDecl(VDPrivate);
11630 auto VDPrivateRefExpr = buildDeclRefExpr(
11631 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
11633 // Add temporary variable to initialize the private copy of the pointer.
11635 buildVarDecl(*this, RefExpr->getExprLoc(), Type, ".devptr.temp");
11636 auto *VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(),
11637 RefExpr->getExprLoc());
11638 AddInitializerToDecl(VDPrivate,
11639 DefaultLvalueConversion(VDInitRefExpr).get(),
11640 /*DirectInit=*/false);
11642 // If required, build a capture to implement the privatization initialized
11643 // with the current list item value.
11644 DeclRefExpr *Ref = nullptr;
11646 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true);
11647 MVLI.ProcessedVarList.push_back(VD ? RefExpr->IgnoreParens() : Ref);
11648 PrivateCopies.push_back(VDPrivateRefExpr);
11649 Inits.push_back(VDInitRefExpr);
11651 // We need to add a data sharing attribute for this variable to make sure it
11652 // is correctly captured. A variable that shows up in a use_device_ptr has
11653 // similar properties of a first private variable.
11654 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref);
11656 // Create a mappable component for the list item. List items in this clause
11657 // only need a component.
11658 MVLI.VarBaseDeclarations.push_back(D);
11659 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
11660 MVLI.VarComponents.back().push_back(
11661 OMPClauseMappableExprCommon::MappableComponent(SimpleRefExpr, D));
11664 if (MVLI.ProcessedVarList.empty())
11667 return OMPUseDevicePtrClause::Create(
11668 Context, StartLoc, LParenLoc, EndLoc, MVLI.ProcessedVarList,
11669 PrivateCopies, Inits, MVLI.VarBaseDeclarations, MVLI.VarComponents);
11672 OMPClause *Sema::ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11673 SourceLocation StartLoc,
11674 SourceLocation LParenLoc,
11675 SourceLocation EndLoc) {
11676 MappableVarListInfo MVLI(VarList);
11677 for (auto &RefExpr : VarList) {
11678 assert(RefExpr && "NULL expr in OpenMP is_device_ptr clause.");
11679 SourceLocation ELoc;
11680 SourceRange ERange;
11681 Expr *SimpleRefExpr = RefExpr;
11682 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
11684 // It will be analyzed later.
11685 MVLI.ProcessedVarList.push_back(RefExpr);
11687 ValueDecl *D = Res.first;
11691 QualType Type = D->getType();
11692 // item should be a pointer or array or reference to pointer or array
11693 if (!Type.getNonReferenceType()->isPointerType() &&
11694 !Type.getNonReferenceType()->isArrayType()) {
11695 Diag(ELoc, diag::err_omp_argument_type_isdeviceptr)
11696 << 0 << RefExpr->getSourceRange();
11700 // Check if the declaration in the clause does not show up in any data
11701 // sharing attribute.
11702 auto DVar = DSAStack->getTopDSA(D, false);
11703 if (isOpenMPPrivate(DVar.CKind)) {
11704 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
11705 << getOpenMPClauseName(DVar.CKind)
11706 << getOpenMPClauseName(OMPC_is_device_ptr)
11707 << getOpenMPDirectiveName(DSAStack->getCurrentDirective());
11708 ReportOriginalDSA(*this, DSAStack, D, DVar);
11712 Expr *ConflictExpr;
11713 if (DSAStack->checkMappableExprComponentListsForDecl(
11714 D, /*CurrentRegionOnly=*/true,
11716 OMPClauseMappableExprCommon::MappableExprComponentListRef R,
11717 OpenMPClauseKind) -> bool {
11718 ConflictExpr = R.front().getAssociatedExpression();
11721 Diag(ELoc, diag::err_omp_map_shared_storage) << RefExpr->getSourceRange();
11722 Diag(ConflictExpr->getExprLoc(), diag::note_used_here)
11723 << ConflictExpr->getSourceRange();
11727 // Store the components in the stack so that they can be used to check
11728 // against other clauses later on.
11729 OMPClauseMappableExprCommon::MappableComponent MC(SimpleRefExpr, D);
11730 DSAStack->addMappableExpressionComponents(
11731 D, MC, /*WhereFoundClauseKind=*/OMPC_is_device_ptr);
11733 // Record the expression we've just processed.
11734 MVLI.ProcessedVarList.push_back(SimpleRefExpr);
11736 // Create a mappable component for the list item. List items in this clause
11737 // only need a component. We use a null declaration to signal fields in
11739 assert((isa<DeclRefExpr>(SimpleRefExpr) ||
11740 isa<CXXThisExpr>(cast<MemberExpr>(SimpleRefExpr)->getBase())) &&
11741 "Unexpected device pointer expression!");
11742 MVLI.VarBaseDeclarations.push_back(
11743 isa<DeclRefExpr>(SimpleRefExpr) ? D : nullptr);
11744 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1);
11745 MVLI.VarComponents.back().push_back(MC);
11748 if (MVLI.ProcessedVarList.empty())
11751 return OMPIsDevicePtrClause::Create(
11752 Context, StartLoc, LParenLoc, EndLoc, MVLI.ProcessedVarList,
11753 MVLI.VarBaseDeclarations, MVLI.VarComponents);