Bug Summary

File:tools/clang/lib/Sema/SemaOpenMP.cpp
Warning:line 3224, column 7
Called C++ object pointer is null

Annotated Source Code

1//===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9/// \file
10/// \brief This file implements semantic analysis for OpenMP directives and
11/// clauses.
12///
13//===----------------------------------------------------------------------===//
14
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"
34using namespace clang;
35
36//===----------------------------------------------------------------------===//
37// Stack of data-sharing attributes for variables
38//===----------------------------------------------------------------------===//
39
40namespace {
41/// \brief Default data sharing attributes, which can be applied to directive.
42enum 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'.
46};
47
48/// \brief Stack for tracking declarations used in OpenMP directives and
49/// clauses and their data-sharing attributes.
50class DSAStackTy final {
51public:
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;
58 DSAVarData() {}
59 };
60 typedef llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4>
61 OperatorOffsetTy;
62
63private:
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;
70 };
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
76 /// found.
77 struct MappedExprComponentTy {
78 OMPClauseMappableExprCommon::MappableExprComponentLists Components;
79 OpenMPClauseKind Kind = OMPC_unknown;
80 };
81 typedef llvm::DenseMap<ValueDecl *, MappedExprComponentTy>
82 MappedExprComponentsTy;
83 typedef llvm::StringMap<std::pair<OMPCriticalDirective *, llvm::APSInt>>
84 CriticalsWithHintsTy;
85 typedef llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>
86 DoacrossDependMapTy;
87
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),
114 ConstructLoc(Loc) {}
115 SharingMapTy() {}
116 };
117
118 typedef SmallVector<SharingMapTy, 4> StackTy;
119
120 /// \brief Stack of used declaration and their data-sharing attributes.
121 StackTy Stack;
122 /// \brief true, if check for DSA must be from parent directive, false, if
123 /// from current directive.
124 OpenMPClauseKind ClauseKindMode = OMPC_unknown;
125 Sema &SemaRef;
126 bool ForceCapturing = false;
127 CriticalsWithHintsTy Criticals;
128
129 typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator;
130
131 DSAVarData getDSA(StackTy::reverse_iterator &Iter, ValueDecl *D);
132
133 /// \brief Checks if the variable is a local for OpenMP region.
134 bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter);
135
136public:
137 explicit DSAStackTy(Sema &S) : Stack(1), SemaRef(S) {}
138
139 bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
140 void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }
141
142 bool isForceVarCapturing() const { return ForceCapturing; }
143 void setForceVarCapturing(bool V) { ForceCapturing = V; }
144
145 void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
146 Scope *CurScope, SourceLocation Loc) {
147 Stack.push_back(SharingMapTy(DKind, DirName, CurScope, Loc));
148 Stack.back().DefaultAttrLoc = Loc;
149 }
150
151 void pop() {
152 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!")((Stack.size() > 1 && "Data-sharing attributes stack is empty!"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Data-sharing attributes stack is empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 152, __PRETTY_FUNCTION__))
;
153 Stack.pop_back();
154 }
155
156 void addCriticalWithHint(OMPCriticalDirective *D, llvm::APSInt Hint) {
157 Criticals[D->getDirectiveName().getAsString()] = std::make_pair(D, Hint);
158 }
159 const std::pair<OMPCriticalDirective *, llvm::APSInt>
160 getCriticalWithHint(const DeclarationNameInfo &Name) const {
161 auto I = Criticals.find(Name.getAsString());
162 if (I != Criticals.end())
163 return I->second;
164 return std::make_pair(nullptr, llvm::APSInt());
165 }
166 /// \brief If 'aligned' declaration for given variable \a D was not seen yet,
167 /// add it and return NULL; otherwise return previous occurrence's expression
168 /// for diagnostics.
169 Expr *addUniqueAligned(ValueDecl *D, Expr *NewDE);
170
171 /// \brief Register specified variable as loop control variable.
172 void addLoopControlVariable(ValueDecl *D, VarDecl *Capture);
173 /// \brief Check if the specified variable is a loop control variable for
174 /// current region.
175 /// \return The index of the loop control variable in the list of associated
176 /// for-loops (from outer to inner).
177 LCDeclInfo isLoopControlVariable(ValueDecl *D);
178 /// \brief Check if the specified variable is a loop control variable for
179 /// parent region.
180 /// \return The index of the loop control variable in the list of associated
181 /// for-loops (from outer to inner).
182 LCDeclInfo isParentLoopControlVariable(ValueDecl *D);
183 /// \brief Get the loop control variable for the I-th loop (or nullptr) in
184 /// parent directive.
185 ValueDecl *getParentLoopControlVariable(unsigned I);
186
187 /// \brief Adds explicit data sharing attribute to the specified declaration.
188 void addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
189 DeclRefExpr *PrivateCopy = nullptr);
190
191 /// \brief Returns data sharing attributes from top of the stack for the
192 /// specified declaration.
193 DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
194 /// \brief Returns data-sharing attributes for the specified declaration.
195 DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent);
196 /// \brief Checks if the specified variables has data-sharing attributes which
197 /// match specified \a CPred predicate in any directive which matches \a DPred
198 /// predicate.
199 DSAVarData hasDSA(ValueDecl *D,
200 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
201 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
202 bool FromParent);
203 /// \brief Checks if the specified variables has data-sharing attributes which
204 /// match specified \a CPred predicate in any innermost directive which
205 /// matches \a DPred predicate.
206 DSAVarData
207 hasInnermostDSA(ValueDecl *D,
208 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
209 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
210 bool FromParent);
211 /// \brief Checks if the specified variables has explicit data-sharing
212 /// attributes which match specified \a CPred predicate at the specified
213 /// OpenMP region.
214 bool hasExplicitDSA(ValueDecl *D,
215 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
216 unsigned Level, bool NotLastprivate = false);
217
218 /// \brief Returns true if the directive at level \Level matches in the
219 /// specified \a DPred predicate.
220 bool hasExplicitDirective(
221 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
222 unsigned Level);
223
224 /// \brief Finds a directive which matches specified \a DPred predicate.
225 bool hasDirective(const llvm::function_ref<bool(OpenMPDirectiveKind,
226 const DeclarationNameInfo &,
227 SourceLocation)> &DPred,
228 bool FromParent);
229
230 /// \brief Returns currently analyzed directive.
231 OpenMPDirectiveKind getCurrentDirective() const {
232 return Stack.back().Directive;
233 }
234 /// \brief Returns parent directive.
235 OpenMPDirectiveKind getParentDirective() const {
236 if (Stack.size() > 2)
237 return Stack[Stack.size() - 2].Directive;
238 return OMPD_unknown;
239 }
240
241 /// \brief Set default data sharing attribute to none.
242 void setDefaultDSANone(SourceLocation Loc) {
243 Stack.back().DefaultAttr = DSA_none;
244 Stack.back().DefaultAttrLoc = Loc;
245 }
246 /// \brief Set default data sharing attribute to shared.
247 void setDefaultDSAShared(SourceLocation Loc) {
248 Stack.back().DefaultAttr = DSA_shared;
249 Stack.back().DefaultAttrLoc = Loc;
250 }
251
252 DefaultDataSharingAttributes getDefaultDSA() const {
253 return Stack.back().DefaultAttr;
254 }
255 SourceLocation getDefaultDSALocation() const {
256 return Stack.back().DefaultAttrLoc;
257 }
258
259 /// \brief Checks if the specified variable is a threadprivate.
260 bool isThreadPrivate(VarDecl *D) {
261 DSAVarData DVar = getTopDSA(D, false);
262 return isOpenMPThreadPrivate(DVar.CKind);
263 }
264
265 /// \brief Marks current region as ordered (it has an 'ordered' clause).
266 void setOrderedRegion(bool IsOrdered, Expr *Param) {
267 Stack.back().OrderedRegion.setInt(IsOrdered);
268 Stack.back().OrderedRegion.setPointer(Param);
269 }
270 /// \brief Returns true, if parent region is ordered (has associated
271 /// 'ordered' clause), false - otherwise.
272 bool isParentOrderedRegion() const {
273 if (Stack.size() > 2)
274 return Stack[Stack.size() - 2].OrderedRegion.getInt();
275 return false;
276 }
277 /// \brief Returns optional parameter for the ordered region.
278 Expr *getParentOrderedRegionParam() const {
279 if (Stack.size() > 2)
280 return Stack[Stack.size() - 2].OrderedRegion.getPointer();
281 return nullptr;
282 }
283 /// \brief Marks current region as nowait (it has a 'nowait' clause).
284 void setNowaitRegion(bool IsNowait = true) {
285 Stack.back().NowaitRegion = IsNowait;
286 }
287 /// \brief Returns true, if parent region is nowait (has associated
288 /// 'nowait' clause), false - otherwise.
289 bool isParentNowaitRegion() const {
290 if (Stack.size() > 2)
291 return Stack[Stack.size() - 2].NowaitRegion;
292 return false;
293 }
294 /// \brief Marks parent region as cancel region.
295 void setParentCancelRegion(bool Cancel = true) {
296 if (Stack.size() > 2)
297 Stack[Stack.size() - 2].CancelRegion =
298 Stack[Stack.size() - 2].CancelRegion || Cancel;
299 }
300 /// \brief Return true if current region has inner cancel construct.
301 bool isCancelRegion() const { return Stack.back().CancelRegion; }
302
303 /// \brief Set collapse value for the region.
304 void setAssociatedLoops(unsigned Val) { Stack.back().AssociatedLoops = Val; }
305 /// \brief Return collapse value for region.
306 unsigned getAssociatedLoops() const { return Stack.back().AssociatedLoops; }
307
308 /// \brief Marks current target region as one with closely nested teams
309 /// region.
310 void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
311 if (Stack.size() > 2)
312 Stack[Stack.size() - 2].InnerTeamsRegionLoc = TeamsRegionLoc;
313 }
314 /// \brief Returns true, if current region has closely nested teams region.
315 bool hasInnerTeamsRegion() const {
316 return getInnerTeamsRegionLoc().isValid();
317 }
318 /// \brief Returns location of the nested teams region (if any).
319 SourceLocation getInnerTeamsRegionLoc() const {
320 if (Stack.size() > 1)
321 return Stack.back().InnerTeamsRegionLoc;
322 return SourceLocation();
323 }
324
325 Scope *getCurScope() const { return Stack.back().CurScope; }
326 Scope *getCurScope() { return Stack.back().CurScope; }
327 SourceLocation getConstructLoc() { return Stack.back().ConstructLoc; }
328
329 /// Do the check specified in \a Check to all component lists and return true
330 /// if any issue is found.
331 bool checkMappableExprComponentListsForDecl(
332 ValueDecl *VD, bool CurrentRegionOnly,
333 const llvm::function_ref<
334 bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
335 OpenMPClauseKind)> &Check) {
336 auto SI = Stack.rbegin();
337 auto SE = Stack.rend();
338
339 if (SI == SE)
340 return false;
341
342 if (CurrentRegionOnly) {
343 SE = std::next(SI);
344 } else {
345 ++SI;
346 }
347
348 for (; SI != SE; ++SI) {
349 auto MI = SI->MappedExprComponents.find(VD);
350 if (MI != SI->MappedExprComponents.end())
351 for (auto &L : MI->second.Components)
352 if (Check(L, MI->second.Kind))
353 return true;
354 }
355 return false;
356 }
357
358 /// Create a new mappable expression component list associated with a given
359 /// declaration and initialize it with the provided list of components.
360 void addMappableExpressionComponents(
361 ValueDecl *VD,
362 OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
363 OpenMPClauseKind WhereFoundClauseKind) {
364 assert(Stack.size() > 1 &&((Stack.size() > 1 && "Not expecting to retrieve components from a empty stack!"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Not expecting to retrieve components from a empty stack!\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 365, __PRETTY_FUNCTION__))
365 "Not expecting to retrieve components from a empty stack!")((Stack.size() > 1 && "Not expecting to retrieve components from a empty stack!"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Not expecting to retrieve components from a empty stack!\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 365, __PRETTY_FUNCTION__))
;
366 auto &MEC = Stack.back().MappedExprComponents[VD];
367 // Create new entry and append the new components there.
368 MEC.Components.resize(MEC.Components.size() + 1);
369 MEC.Components.back().append(Components.begin(), Components.end());
370 MEC.Kind = WhereFoundClauseKind;
371 }
372
373 unsigned getNestingLevel() const {
374 assert(Stack.size() > 1)((Stack.size() > 1) ? static_cast<void> (0) : __assert_fail
("Stack.size() > 1", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 374, __PRETTY_FUNCTION__))
;
375 return Stack.size() - 2;
376 }
377 void addDoacrossDependClause(OMPDependClause *C, OperatorOffsetTy &OpsOffs) {
378 assert(Stack.size() > 2)((Stack.size() > 2) ? static_cast<void> (0) : __assert_fail
("Stack.size() > 2", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 378, __PRETTY_FUNCTION__))
;
379 assert(isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive))((isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive
)) ? static_cast<void> (0) : __assert_fail ("isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive)"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 379, __PRETTY_FUNCTION__))
;
380 Stack[Stack.size() - 2].DoacrossDepends.insert({C, OpsOffs});
381 }
382 llvm::iterator_range<DoacrossDependMapTy::const_iterator>
383 getDoacrossDependClauses() const {
384 assert(Stack.size() > 1)((Stack.size() > 1) ? static_cast<void> (0) : __assert_fail
("Stack.size() > 1", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 384, __PRETTY_FUNCTION__))
;
385 if (isOpenMPWorksharingDirective(Stack[Stack.size() - 1].Directive)) {
386 auto &Ref = Stack[Stack.size() - 1].DoacrossDepends;
387 return llvm::make_range(Ref.begin(), Ref.end());
388 }
389 return llvm::make_range(Stack[0].DoacrossDepends.end(),
390 Stack[0].DoacrossDepends.end());
391 }
392};
393bool isParallelOrTaskRegion(OpenMPDirectiveKind DKind) {
394 return isOpenMPParallelDirective(DKind) || isOpenMPTaskingDirective(DKind) ||
395 isOpenMPTeamsDirective(DKind) || DKind == OMPD_unknown;
396}
397} // namespace
398
399static ValueDecl *getCanonicalDecl(ValueDecl *D) {
400 auto *VD = dyn_cast<VarDecl>(D);
401 auto *FD = dyn_cast<FieldDecl>(D);
402 if (VD != nullptr) {
403 VD = VD->getCanonicalDecl();
404 D = VD;
405 } else {
406 assert(FD)((FD) ? static_cast<void> (0) : __assert_fail ("FD", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 406, __PRETTY_FUNCTION__))
;
407 FD = FD->getCanonicalDecl();
408 D = FD;
409 }
410 return D;
411}
412
413DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator &Iter,
414 ValueDecl *D) {
415 D = getCanonicalDecl(D);
416 auto *VD = dyn_cast<VarDecl>(D);
417 auto *FD = dyn_cast<FieldDecl>(D);
418 DSAVarData DVar;
419 if (Iter == std::prev(Stack.rend())) {
420 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
421 // in a region but not in construct]
422 // File-scope or namespace-scope variables referenced in called routines
423 // in the region are shared unless they appear in a threadprivate
424 // directive.
425 if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(D))
426 DVar.CKind = OMPC_shared;
427
428 // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
429 // in a region but not in construct]
430 // Variables with static storage duration that are declared in called
431 // routines in the region are shared.
432 if (VD && VD->hasGlobalStorage())
433 DVar.CKind = OMPC_shared;
434
435 // Non-static data members are shared by default.
436 if (FD)
437 DVar.CKind = OMPC_shared;
438
439 return DVar;
440 }
441
442 DVar.DKind = Iter->Directive;
443 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
444 // in a Construct, C/C++, predetermined, p.1]
445 // Variables with automatic storage duration that are declared in a scope
446 // inside the construct are private.
447 if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
448 (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
449 DVar.CKind = OMPC_private;
450 return DVar;
451 }
452
453 // Explicitly specified attributes and local variables with predetermined
454 // attributes.
455 if (Iter->SharingMap.count(D)) {
456 DVar.RefExpr = Iter->SharingMap[D].RefExpr.getPointer();
457 DVar.PrivateCopy = Iter->SharingMap[D].PrivateCopy;
458 DVar.CKind = Iter->SharingMap[D].Attributes;
459 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
460 return DVar;
461 }
462
463 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
464 // in a Construct, C/C++, implicitly determined, p.1]
465 // In a parallel or task construct, the data-sharing attributes of these
466 // variables are determined by the default clause, if present.
467 switch (Iter->DefaultAttr) {
468 case DSA_shared:
469 DVar.CKind = OMPC_shared;
470 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
471 return DVar;
472 case DSA_none:
473 return DVar;
474 case DSA_unspecified:
475 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
476 // in a Construct, implicitly determined, p.2]
477 // In a parallel construct, if no default clause is present, these
478 // variables are shared.
479 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
480 if (isOpenMPParallelDirective(DVar.DKind) ||
481 isOpenMPTeamsDirective(DVar.DKind)) {
482 DVar.CKind = OMPC_shared;
483 return DVar;
484 }
485
486 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
487 // in a Construct, implicitly determined, p.4]
488 // In a task construct, if no default clause is present, a variable that in
489 // the enclosing context is determined to be shared by all implicit tasks
490 // bound to the current team is shared.
491 if (isOpenMPTaskingDirective(DVar.DKind)) {
492 DSAVarData DVarTemp;
493 for (StackTy::reverse_iterator I = std::next(Iter), EE = Stack.rend();
494 I != EE; ++I) {
495 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
496 // Referenced in a Construct, implicitly determined, p.6]
497 // In a task construct, if no default clause is present, a variable
498 // whose data-sharing attribute is not determined by the rules above is
499 // firstprivate.
500 DVarTemp = getDSA(I, D);
501 if (DVarTemp.CKind != OMPC_shared) {
502 DVar.RefExpr = nullptr;
503 DVar.CKind = OMPC_firstprivate;
504 return DVar;
505 }
506 if (isParallelOrTaskRegion(I->Directive))
507 break;
508 }
509 DVar.CKind =
510 (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
511 return DVar;
512 }
513 }
514 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
515 // in a Construct, implicitly determined, p.3]
516 // For constructs other than task, if no default clause is present, these
517 // variables inherit their data-sharing attributes from the enclosing
518 // context.
519 return getDSA(++Iter, D);
520}
521
522Expr *DSAStackTy::addUniqueAligned(ValueDecl *D, Expr *NewDE) {
523 assert(Stack.size() > 1 && "Data sharing attributes stack is empty")((Stack.size() > 1 && "Data sharing attributes stack is empty"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Data sharing attributes stack is empty\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 523, __PRETTY_FUNCTION__))
;
524 D = getCanonicalDecl(D);
525 auto It = Stack.back().AlignedMap.find(D);
526 if (It == Stack.back().AlignedMap.end()) {
527 assert(NewDE && "Unexpected nullptr expr to be added into aligned map")((NewDE && "Unexpected nullptr expr to be added into aligned map"
) ? static_cast<void> (0) : __assert_fail ("NewDE && \"Unexpected nullptr expr to be added into aligned map\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 527, __PRETTY_FUNCTION__))
;
528 Stack.back().AlignedMap[D] = NewDE;
529 return nullptr;
530 } else {
531 assert(It->second && "Unexpected nullptr expr in the aligned map")((It->second && "Unexpected nullptr expr in the aligned map"
) ? static_cast<void> (0) : __assert_fail ("It->second && \"Unexpected nullptr expr in the aligned map\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 531, __PRETTY_FUNCTION__))
;
532 return It->second;
533 }
534 return nullptr;
535}
536
537void DSAStackTy::addLoopControlVariable(ValueDecl *D, VarDecl *Capture) {
538 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty")((Stack.size() > 1 && "Data-sharing attributes stack is empty"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Data-sharing attributes stack is empty\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 538, __PRETTY_FUNCTION__))
;
539 D = getCanonicalDecl(D);
540 Stack.back().LCVMap.insert(
541 std::make_pair(D, LCDeclInfo(Stack.back().LCVMap.size() + 1, Capture)));
542}
543
544DSAStackTy::LCDeclInfo DSAStackTy::isLoopControlVariable(ValueDecl *D) {
545 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty")((Stack.size() > 1 && "Data-sharing attributes stack is empty"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Data-sharing attributes stack is empty\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 545, __PRETTY_FUNCTION__))
;
546 D = getCanonicalDecl(D);
547 return Stack.back().LCVMap.count(D) > 0 ? Stack.back().LCVMap[D]
548 : LCDeclInfo(0, nullptr);
549}
550
551DSAStackTy::LCDeclInfo DSAStackTy::isParentLoopControlVariable(ValueDecl *D) {
552 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty")((Stack.size() > 2 && "Data-sharing attributes stack is empty"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 2 && \"Data-sharing attributes stack is empty\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 552, __PRETTY_FUNCTION__))
;
553 D = getCanonicalDecl(D);
554 return Stack[Stack.size() - 2].LCVMap.count(D) > 0
555 ? Stack[Stack.size() - 2].LCVMap[D]
556 : LCDeclInfo(0, nullptr);
557}
558
559ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) {
560 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty")((Stack.size() > 2 && "Data-sharing attributes stack is empty"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 2 && \"Data-sharing attributes stack is empty\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 560, __PRETTY_FUNCTION__))
;
561 if (Stack[Stack.size() - 2].LCVMap.size() < I)
562 return nullptr;
563 for (auto &Pair : Stack[Stack.size() - 2].LCVMap) {
564 if (Pair.second.first == I)
565 return Pair.first;
566 }
567 return nullptr;
568}
569
570void DSAStackTy::addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A,
571 DeclRefExpr *PrivateCopy) {
572 D = getCanonicalDecl(D);
573 if (A == OMPC_threadprivate) {
574 auto &Data = Stack[0].SharingMap[D];
575 Data.Attributes = A;
576 Data.RefExpr.setPointer(E);
577 Data.PrivateCopy = nullptr;
578 } else {
579 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty")((Stack.size() > 1 && "Data-sharing attributes stack is empty"
) ? static_cast<void> (0) : __assert_fail ("Stack.size() > 1 && \"Data-sharing attributes stack is empty\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 579, __PRETTY_FUNCTION__))
;
580 auto &Data = Stack.back().SharingMap[D];
581 assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||((Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
(A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate
) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate
) || (isLoopControlVariable(D).first && A == OMPC_private
)) ? static_cast<void> (0) : __assert_fail ("Data.Attributes == OMPC_unknown || (A == Data.Attributes) || (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) || (isLoopControlVariable(D).first && A == OMPC_private)"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 584, __PRETTY_FUNCTION__))
582 (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||((Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
(A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate
) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate
) || (isLoopControlVariable(D).first && A == OMPC_private
)) ? static_cast<void> (0) : __assert_fail ("Data.Attributes == OMPC_unknown || (A == Data.Attributes) || (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) || (isLoopControlVariable(D).first && A == OMPC_private)"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 584, __PRETTY_FUNCTION__))
583 (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||((Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
(A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate
) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate
) || (isLoopControlVariable(D).first && A == OMPC_private
)) ? static_cast<void> (0) : __assert_fail ("Data.Attributes == OMPC_unknown || (A == Data.Attributes) || (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) || (isLoopControlVariable(D).first && A == OMPC_private)"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 584, __PRETTY_FUNCTION__))
584 (isLoopControlVariable(D).first && A == OMPC_private))((Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||
(A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate
) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate
) || (isLoopControlVariable(D).first && A == OMPC_private
)) ? static_cast<void> (0) : __assert_fail ("Data.Attributes == OMPC_unknown || (A == Data.Attributes) || (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) || (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) || (isLoopControlVariable(D).first && A == OMPC_private)"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 584, __PRETTY_FUNCTION__))
;
585 if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
586 Data.RefExpr.setInt(/*IntVal=*/true);
587 return;
588 }
589 const bool IsLastprivate =
590 A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
591 Data.Attributes = A;
592 Data.RefExpr.setPointerAndInt(E, IsLastprivate);
593 Data.PrivateCopy = PrivateCopy;
594 if (PrivateCopy) {
595 auto &Data = Stack.back().SharingMap[PrivateCopy->getDecl()];
596 Data.Attributes = A;
597 Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
598 Data.PrivateCopy = nullptr;
599 }
600 }
601}
602
603bool DSAStackTy::isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter) {
604 D = D->getCanonicalDecl();
605 if (Stack.size() > 2) {
606 reverse_iterator I = Iter, E = std::prev(Stack.rend());
607 Scope *TopScope = nullptr;
608 while (I != E && !isParallelOrTaskRegion(I->Directive)) {
609 ++I;
610 }
611 if (I == E)
612 return false;
613 TopScope = I->CurScope ? I->CurScope->getParent() : nullptr;
614 Scope *CurScope = getCurScope();
615 while (CurScope != TopScope && !CurScope->isDeclScope(D)) {
616 CurScope = CurScope->getParent();
617 }
618 return CurScope != TopScope;
619 }
620 return false;
621}
622
623/// \brief Build a variable declaration for OpenMP loop iteration variable.
624static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
625 StringRef Name, const AttrVec *Attrs = nullptr) {
626 DeclContext *DC = SemaRef.CurContext;
627 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
628 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
629 VarDecl *Decl =
630 VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
631 if (Attrs) {
632 for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
633 I != E; ++I)
634 Decl->addAttr(*I);
635 }
636 Decl->setImplicit();
637 return Decl;
638}
639
640static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
641 SourceLocation Loc,
642 bool RefersToCapture = false) {
643 D->setReferenced();
644 D->markUsed(S.Context);
645 return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
646 SourceLocation(), D, RefersToCapture, Loc, Ty,
647 VK_LValue);
648}
649
650DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D, bool FromParent) {
651 D = getCanonicalDecl(D);
652 DSAVarData DVar;
653
654 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
655 // in a Construct, C/C++, predetermined, p.1]
656 // Variables appearing in threadprivate directives are threadprivate.
657 auto *VD = dyn_cast<VarDecl>(D);
658 if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
659 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
660 SemaRef.getLangOpts().OpenMPUseTLS &&
661 SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
662 (VD && VD->getStorageClass() == SC_Register &&
663 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
664 addDSA(D, buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
665 D->getLocation()),
666 OMPC_threadprivate);
667 }
668 if (Stack[0].SharingMap.count(D)) {
669 DVar.RefExpr = Stack[0].SharingMap[D].RefExpr.getPointer();
670 DVar.CKind = OMPC_threadprivate;
671 return DVar;
672 }
673
674 if (Stack.size() == 1) {
675 // Not in OpenMP execution region and top scope was already checked.
676 return DVar;
677 }
678
679 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
680 // in a Construct, C/C++, predetermined, p.4]
681 // Static data members are shared.
682 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
683 // in a Construct, C/C++, predetermined, p.7]
684 // Variables with static storage duration that are declared in a scope
685 // inside the construct are shared.
686 auto &&MatchesAlways = [](OpenMPDirectiveKind) -> bool { return true; };
687 if (VD && VD->isStaticDataMember()) {
688 DSAVarData DVarTemp = hasDSA(D, isOpenMPPrivate, MatchesAlways, FromParent);
689 if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
690 return DVar;
691
692 DVar.CKind = OMPC_shared;
693 return DVar;
694 }
695
696 QualType Type = D->getType().getNonReferenceType().getCanonicalType();
697 bool IsConstant = Type.isConstant(SemaRef.getASTContext());
698 Type = SemaRef.getASTContext().getBaseElementType(Type);
699 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
700 // in a Construct, C/C++, predetermined, p.6]
701 // Variables with const qualified type having no mutable member are
702 // shared.
703 CXXRecordDecl *RD =
704 SemaRef.getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr;
705 if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
706 if (auto *CTD = CTSD->getSpecializedTemplate())
707 RD = CTD->getTemplatedDecl();
708 if (IsConstant &&
709 !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() &&
710 RD->hasMutableFields())) {
711 // Variables with const-qualified type having no mutable member may be
712 // listed in a firstprivate clause, even if they are static data members.
713 DSAVarData DVarTemp = hasDSA(
714 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_firstprivate; },
715 MatchesAlways, FromParent);
716 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr)
717 return DVar;
718
719 DVar.CKind = OMPC_shared;
720 return DVar;
721 }
722
723 // Explicitly specified attributes and local variables with predetermined
724 // attributes.
725 auto StartI = std::next(Stack.rbegin());
726 auto EndI = std::prev(Stack.rend());
727 if (FromParent && StartI != EndI) {
728 StartI = std::next(StartI);
729 }
730 auto I = std::prev(StartI);
731 if (I->SharingMap.count(D)) {
732 DVar.RefExpr = I->SharingMap[D].RefExpr.getPointer();
733 DVar.PrivateCopy = I->SharingMap[D].PrivateCopy;
734 DVar.CKind = I->SharingMap[D].Attributes;
735 DVar.ImplicitDSALoc = I->DefaultAttrLoc;
736 }
737
738 return DVar;
739}
740
741DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
742 bool FromParent) {
743 D = getCanonicalDecl(D);
744 auto StartI = Stack.rbegin();
745 auto EndI = std::prev(Stack.rend());
746 if (FromParent && StartI != EndI) {
747 StartI = std::next(StartI);
748 }
749 return getDSA(StartI, D);
750}
751
752DSAStackTy::DSAVarData
753DSAStackTy::hasDSA(ValueDecl *D,
754 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
755 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
756 bool FromParent) {
757 D = getCanonicalDecl(D);
758 auto StartI = std::next(Stack.rbegin());
759 auto EndI = Stack.rend();
760 if (FromParent && StartI != EndI) {
761 StartI = std::next(StartI);
762 }
763 for (auto I = StartI, EE = EndI; I != EE; ++I) {
764 if (!DPred(I->Directive) && !isParallelOrTaskRegion(I->Directive))
765 continue;
766 DSAVarData DVar = getDSA(I, D);
767 if (CPred(DVar.CKind))
768 return DVar;
769 }
770 return DSAVarData();
771}
772
773DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
774 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
775 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
776 bool FromParent) {
777 D = getCanonicalDecl(D);
778 auto StartI = std::next(Stack.rbegin());
779 auto EndI = Stack.rend();
780 if (FromParent && StartI != EndI)
781 StartI = std::next(StartI);
782 if (StartI == EndI || !DPred(StartI->Directive))
783 return DSAVarData();
784 DSAVarData DVar = getDSA(StartI, D);
785 return CPred(DVar.CKind) ? DVar : DSAVarData();
786}
787
788bool DSAStackTy::hasExplicitDSA(
789 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred,
790 unsigned Level, bool NotLastprivate) {
791 if (CPred(ClauseKindMode))
792 return true;
793 D = getCanonicalDecl(D);
794 auto StartI = std::next(Stack.begin());
795 auto EndI = Stack.end();
796 if (std::distance(StartI, EndI) <= (int)Level)
797 return false;
798 std::advance(StartI, Level);
799 return (StartI->SharingMap.count(D) > 0) &&
800 StartI->SharingMap[D].RefExpr.getPointer() &&
801 CPred(StartI->SharingMap[D].Attributes) &&
802 (!NotLastprivate || !StartI->SharingMap[D].RefExpr.getInt());
803}
804
805bool DSAStackTy::hasExplicitDirective(
806 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred,
807 unsigned Level) {
808 auto StartI = std::next(Stack.begin());
809 auto EndI = Stack.end();
810 if (std::distance(StartI, EndI) <= (int)Level)
811 return false;
812 std::advance(StartI, Level);
813 return DPred(StartI->Directive);
814}
815
816bool DSAStackTy::hasDirective(
817 const llvm::function_ref<bool(OpenMPDirectiveKind,
818 const DeclarationNameInfo &, SourceLocation)>
819 &DPred,
820 bool FromParent) {
821 // We look only in the enclosing region.
822 if (Stack.size() < 2)
823 return false;
824 auto StartI = std::next(Stack.rbegin());
825 auto EndI = std::prev(Stack.rend());
826 if (FromParent && StartI != EndI) {
827 StartI = std::next(StartI);
828 }
829 for (auto I = StartI, EE = EndI; I != EE; ++I) {
830 if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc))
831 return true;
832 }
833 return false;
834}
835
836void Sema::InitDataSharingAttributesStack() {
837 VarDataSharingAttributesStack = new DSAStackTy(*this);
838}
839
840#define DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
static_cast<DSAStackTy *>(VarDataSharingAttributesStack)
841
842bool Sema::IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level) {
843 assert(LangOpts.OpenMP && "OpenMP is not allowed")((LangOpts.OpenMP && "OpenMP is not allowed") ? static_cast
<void> (0) : __assert_fail ("LangOpts.OpenMP && \"OpenMP is not allowed\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 843, __PRETTY_FUNCTION__))
;
844
845 auto &Ctx = getASTContext();
846 bool IsByRef = true;
847
848 // Find the directive that is associated with the provided scope.
849 auto Ty = D->getType();
850
851 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) {
852 // This table summarizes how a given variable should be passed to the device
853 // given its type and the clauses where it appears. This table is based on
854 // the description in OpenMP 4.5 [2.10.4, target Construct] and
855 // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses].
856 //
857 // =========================================================================
858 // | type | defaultmap | pvt | first | is_device_ptr | map | res. |
859 // | |(tofrom:scalar)| | pvt | | | |
860 // =========================================================================
861 // | scl | | | | - | | bycopy|
862 // | scl | | - | x | - | - | bycopy|
863 // | scl | | x | - | - | - | null |
864 // | scl | x | | | - | | byref |
865 // | scl | x | - | x | - | - | bycopy|
866 // | scl | x | x | - | - | - | null |
867 // | scl | | - | - | - | x | byref |
868 // | scl | x | - | - | - | x | byref |
869 //
870 // | agg | n.a. | | | - | | byref |
871 // | agg | n.a. | - | x | - | - | byref |
872 // | agg | n.a. | x | - | - | - | null |
873 // | agg | n.a. | - | - | - | x | byref |
874 // | agg | n.a. | - | - | - | x[] | byref |
875 //
876 // | ptr | n.a. | | | - | | bycopy|
877 // | ptr | n.a. | - | x | - | - | bycopy|
878 // | ptr | n.a. | x | - | - | - | null |
879 // | ptr | n.a. | - | - | - | x | byref |
880 // | ptr | n.a. | - | - | - | x[] | bycopy|
881 // | ptr | n.a. | - | - | x | | bycopy|
882 // | ptr | n.a. | - | - | x | x | bycopy|
883 // | ptr | n.a. | - | - | x | x[] | bycopy|
884 // =========================================================================
885 // Legend:
886 // scl - scalar
887 // ptr - pointer
888 // agg - aggregate
889 // x - applies
890 // - - invalid in this combination
891 // [] - mapped with an array section
892 // byref - should be mapped by reference
893 // byval - should be mapped by value
894 // null - initialize a local variable to null on the device
895 //
896 // Observations:
897 // - All scalar declarations that show up in a map clause have to be passed
898 // by reference, because they may have been mapped in the enclosing data
899 // environment.
900 // - If the scalar value does not fit the size of uintptr, it has to be
901 // passed by reference, regardless the result in the table above.
902 // - For pointers mapped by value that have either an implicit map or an
903 // array section, the runtime library may pass the NULL value to the
904 // device instead of the value passed to it by the compiler.
905
906 if (Ty->isReferenceType())
907 Ty = Ty->castAs<ReferenceType>()->getPointeeType();
908
909 // Locate map clauses and see if the variable being captured is referred to
910 // in any of those clauses. Here we only care about variables, not fields,
911 // because fields are part of aggregates.
912 bool IsVariableUsedInMapClause = false;
913 bool IsVariableAssociatedWithSection = false;
914
915 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->checkMappableExprComponentListsForDecl(
916 D, /*CurrentRegionOnly=*/true,
917 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef
918 MapExprComponents,
919 OpenMPClauseKind WhereFoundClauseKind) {
920 // Only the map clause information influences how a variable is
921 // captured. E.g. is_device_ptr does not require changing the default
922 // behavior.
923 if (WhereFoundClauseKind != OMPC_map)
924 return false;
925
926 auto EI = MapExprComponents.rbegin();
927 auto EE = MapExprComponents.rend();
928
929 assert(EI != EE && "Invalid map expression!")((EI != EE && "Invalid map expression!") ? static_cast
<void> (0) : __assert_fail ("EI != EE && \"Invalid map expression!\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 929, __PRETTY_FUNCTION__))
;
930
931 if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
932 IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;
933
934 ++EI;
935 if (EI == EE)
936 return false;
937
938 if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
939 isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
940 isa<MemberExpr>(EI->getAssociatedExpression())) {
941 IsVariableAssociatedWithSection = true;
942 // There is nothing more we need to know about this variable.
943 return true;
944 }
945
946 // Keep looking for more map info.
947 return false;
948 });
949
950 if (IsVariableUsedInMapClause) {
951 // If variable is identified in a map clause it is always captured by
952 // reference except if it is a pointer that is dereferenced somehow.
953 IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
954 } else {
955 // By default, all the data that has a scalar type is mapped by copy.
956 IsByRef = !Ty->isScalarType();
957 }
958 }
959
960 if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
961 IsByRef = !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasExplicitDSA(
962 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_firstprivate; },
963 Level, /*NotLastprivate=*/true);
964 }
965
966 // When passing data by copy, we need to make sure it fits the uintptr size
967 // and alignment, because the runtime library only deals with uintptr types.
968 // If it does not fit the uintptr size, we need to pass the data by reference
969 // instead.
970 if (!IsByRef &&
971 (Ctx.getTypeSizeInChars(Ty) >
972 Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
973 Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
974 IsByRef = true;
975 }
976
977 return IsByRef;
978}
979
980unsigned Sema::getOpenMPNestingLevel() const {
981 assert(getLangOpts().OpenMP)((getLangOpts().OpenMP) ? static_cast<void> (0) : __assert_fail
("getLangOpts().OpenMP", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 981, __PRETTY_FUNCTION__))
;
982 return DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getNestingLevel();
983}
984
985VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) {
986 assert(LangOpts.OpenMP && "OpenMP is not allowed")((LangOpts.OpenMP && "OpenMP is not allowed") ? static_cast
<void> (0) : __assert_fail ("LangOpts.OpenMP && \"OpenMP is not allowed\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 986, __PRETTY_FUNCTION__))
;
987 D = getCanonicalDecl(D);
988
989 // If we are attempting to capture a global variable in a directive with
990 // 'target' we return true so that this global is also mapped to the device.
991 //
992 // FIXME: If the declaration is enclosed in a 'declare target' directive,
993 // then it should not be captured. Therefore, an extra check has to be
994 // inserted here once support for 'declare target' is added.
995 //
996 auto *VD = dyn_cast<VarDecl>(D);
997 if (VD && !VD->hasLocalStorage()) {
998 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective() == OMPD_target &&
999 !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isClauseParsingMode())
1000 return VD;
1001 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasDirective(
1002 [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
1003 SourceLocation) -> bool {
1004 return isOpenMPTargetExecutionDirective(K);
1005 },
1006 false))
1007 return VD;
1008 }
1009
1010 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective() != OMPD_unknown &&
1011 (!DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isClauseParsingMode() ||
1012 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getParentDirective() != OMPD_unknown)) {
1013 auto &&Info = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isLoopControlVariable(D);
1014 if (Info.first ||
1015 (VD && VD->hasLocalStorage() &&
1016 isParallelOrTaskRegion(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective())) ||
1017 (VD && DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isForceVarCapturing()))
1018 return VD ? VD : Info.second;
1019 auto DVarPrivate = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getTopDSA(D, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isClauseParsingMode());
1020 if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind))
1021 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1022 DVarPrivate = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasDSA(
1023 D, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; },
1024 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isClauseParsingMode());
1025 if (DVarPrivate.CKind != OMPC_unknown)
1026 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
1027 }
1028 return nullptr;
1029}
1030
1031bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) {
1032 assert(LangOpts.OpenMP && "OpenMP is not allowed")((LangOpts.OpenMP && "OpenMP is not allowed") ? static_cast
<void> (0) : __assert_fail ("LangOpts.OpenMP && \"OpenMP is not allowed\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 1032, __PRETTY_FUNCTION__))
;
1033 return DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasExplicitDSA(
1034 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level);
1035}
1036
1037bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) {
1038 assert(LangOpts.OpenMP && "OpenMP is not allowed")((LangOpts.OpenMP && "OpenMP is not allowed") ? static_cast
<void> (0) : __assert_fail ("LangOpts.OpenMP && \"OpenMP is not allowed\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 1038, __PRETTY_FUNCTION__))
;
1039 // Return true if the current level is no longer enclosed in a target region.
1040
1041 auto *VD = dyn_cast<VarDecl>(D);
1042 return VD && !VD->hasLocalStorage() &&
1043 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasExplicitDirective(isOpenMPTargetExecutionDirective,
1044 Level);
1045}
1046
1047void Sema::DestroyDataSharingAttributesStack() { delete DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
; }
1048
1049void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
1050 const DeclarationNameInfo &DirName,
1051 Scope *CurScope, SourceLocation Loc) {
1052 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->push(DKind, DirName, CurScope, Loc);
1053 PushExpressionEvaluationContext(PotentiallyEvaluated);
1054}
1055
1056void Sema::StartOpenMPClause(OpenMPClauseKind K) {
1057 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setClauseParsingMode(K);
1058}
1059
1060void Sema::EndOpenMPClause() {
1061 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setClauseParsingMode(/*K=*/OMPC_unknown);
1062}
1063
1064void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
1065 // OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
1066 // A variable of class type (or array thereof) that appears in a lastprivate
1067 // clause requires an accessible, unambiguous default constructor for the
1068 // class type, unless the list item is also specified in a firstprivate
1069 // clause.
1070 if (auto *D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
1071 for (auto *C : D->clauses()) {
1072 if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
1073 SmallVector<Expr *, 8> PrivateCopies;
1074 for (auto *DE : Clause->varlists()) {
1075 if (DE->isValueDependent() || DE->isTypeDependent()) {
1076 PrivateCopies.push_back(nullptr);
1077 continue;
1078 }
1079 auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
1080 VarDecl *VD = cast<VarDecl>(DRE->getDecl());
1081 QualType Type = VD->getType().getNonReferenceType();
1082 auto DVar = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getTopDSA(VD, false);
1083 if (DVar.CKind == OMPC_lastprivate) {
1084 // Generate helper private variable and initialize it with the
1085 // default value. The address of the original variable is replaced
1086 // by the address of the new private variable in CodeGen. This new
1087 // variable is not added to IdResolver, so the code in the OpenMP
1088 // region uses original variable for proper diagnostics.
1089 auto *VDPrivate = buildVarDecl(
1090 *this, DE->getExprLoc(), Type.getUnqualifiedType(),
1091 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr);
1092 ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false);
1093 if (VDPrivate->isInvalidDecl())
1094 continue;
1095 PrivateCopies.push_back(buildDeclRefExpr(
1096 *this, VDPrivate, DE->getType(), DE->getExprLoc()));
1097 } else {
1098 // The variable is also a firstprivate, so initialization sequence
1099 // for private copy is generated already.
1100 PrivateCopies.push_back(nullptr);
1101 }
1102 }
1103 // Set initializers to private copies if no errors were found.
1104 if (PrivateCopies.size() == Clause->varlist_size())
1105 Clause->setPrivateCopies(PrivateCopies);
1106 }
1107 }
1108 }
1109
1110 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->pop();
1111 DiscardCleanupsInEvaluationContext();
1112 PopExpressionEvaluationContext();
1113}
1114
1115static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1116 Expr *NumIterations, Sema &SemaRef,
1117 Scope *S, DSAStackTy *Stack);
1118
1119namespace {
1120
1121class VarDeclFilterCCC : public CorrectionCandidateCallback {
1122private:
1123 Sema &SemaRef;
1124
1125public:
1126 explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
1127 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1128 NamedDecl *ND = Candidate.getCorrectionDecl();
1129 if (auto *VD = dyn_cast_or_null<VarDecl>(ND)) {
1130 return VD->hasGlobalStorage() &&
1131 SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1132 SemaRef.getCurScope());
1133 }
1134 return false;
1135 }
1136};
1137
1138class VarOrFuncDeclFilterCCC : public CorrectionCandidateCallback {
1139private:
1140 Sema &SemaRef;
1141
1142public:
1143 explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
1144 bool ValidateCandidate(const TypoCorrection &Candidate) override {
1145 NamedDecl *ND = Candidate.getCorrectionDecl();
1146 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) {
1147 return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
1148 SemaRef.getCurScope());
1149 }
1150 return false;
1151 }
1152};
1153
1154} // namespace
1155
1156ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
1157 CXXScopeSpec &ScopeSpec,
1158 const DeclarationNameInfo &Id) {
1159 LookupResult Lookup(*this, Id, LookupOrdinaryName);
1160 LookupParsedName(Lookup, CurScope, &ScopeSpec, true);
1161
1162 if (Lookup.isAmbiguous())
1163 return ExprError();
1164
1165 VarDecl *VD;
1166 if (!Lookup.isSingleResult()) {
1167 if (TypoCorrection Corrected = CorrectTypo(
1168 Id, LookupOrdinaryName, CurScope, nullptr,
1169 llvm::make_unique<VarDeclFilterCCC>(*this), CTK_ErrorRecovery)) {
1170 diagnoseTypo(Corrected,
1171 PDiag(Lookup.empty()
1172 ? diag::err_undeclared_var_use_suggest
1173 : diag::err_omp_expected_var_arg_suggest)
1174 << Id.getName());
1175 VD = Corrected.getCorrectionDeclAs<VarDecl>();
1176 } else {
1177 Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
1178 : diag::err_omp_expected_var_arg)
1179 << Id.getName();
1180 return ExprError();
1181 }
1182 } else {
1183 if (!(VD = Lookup.getAsSingle<VarDecl>())) {
1184 Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
1185 Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
1186 return ExprError();
1187 }
1188 }
1189 Lookup.suppressDiagnostics();
1190
1191 // OpenMP [2.9.2, Syntax, C/C++]
1192 // Variables must be file-scope, namespace-scope, or static block-scope.
1193 if (!VD->hasGlobalStorage()) {
1194 Diag(Id.getLoc(), diag::err_omp_global_var_arg)
1195 << getOpenMPDirectiveName(OMPD_threadprivate) << !VD->isStaticLocal();
1196 bool IsDecl =
1197 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1198 Diag(VD->getLocation(),
1199 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1200 << VD;
1201 return ExprError();
1202 }
1203
1204 VarDecl *CanonicalVD = VD->getCanonicalDecl();
1205 NamedDecl *ND = cast<NamedDecl>(CanonicalVD);
1206 // OpenMP [2.9.2, Restrictions, C/C++, p.2]
1207 // A threadprivate directive for file-scope variables must appear outside
1208 // any definition or declaration.
1209 if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
1210 !getCurLexicalContext()->isTranslationUnit()) {
1211 Diag(Id.getLoc(), diag::err_omp_var_scope)
1212 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1213 bool IsDecl =
1214 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1215 Diag(VD->getLocation(),
1216 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1217 << VD;
1218 return ExprError();
1219 }
1220 // OpenMP [2.9.2, Restrictions, C/C++, p.3]
1221 // A threadprivate directive for static class member variables must appear
1222 // in the class definition, in the same scope in which the member
1223 // variables are declared.
1224 if (CanonicalVD->isStaticDataMember() &&
1225 !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
1226 Diag(Id.getLoc(), diag::err_omp_var_scope)
1227 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1228 bool IsDecl =
1229 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1230 Diag(VD->getLocation(),
1231 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1232 << VD;
1233 return ExprError();
1234 }
1235 // OpenMP [2.9.2, Restrictions, C/C++, p.4]
1236 // A threadprivate directive for namespace-scope variables must appear
1237 // outside any definition or declaration other than the namespace
1238 // definition itself.
1239 if (CanonicalVD->getDeclContext()->isNamespace() &&
1240 (!getCurLexicalContext()->isFileContext() ||
1241 !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
1242 Diag(Id.getLoc(), diag::err_omp_var_scope)
1243 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1244 bool IsDecl =
1245 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1246 Diag(VD->getLocation(),
1247 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1248 << VD;
1249 return ExprError();
1250 }
1251 // OpenMP [2.9.2, Restrictions, C/C++, p.6]
1252 // A threadprivate directive for static block-scope variables must appear
1253 // in the scope of the variable and not in a nested scope.
1254 if (CanonicalVD->isStaticLocal() && CurScope &&
1255 !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
1256 Diag(Id.getLoc(), diag::err_omp_var_scope)
1257 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1258 bool IsDecl =
1259 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1260 Diag(VD->getLocation(),
1261 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1262 << VD;
1263 return ExprError();
1264 }
1265
1266 // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
1267 // A threadprivate directive must lexically precede all references to any
1268 // of the variables in its list.
1269 if (VD->isUsed() && !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isThreadPrivate(VD)) {
1270 Diag(Id.getLoc(), diag::err_omp_var_used)
1271 << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
1272 return ExprError();
1273 }
1274
1275 QualType ExprType = VD->getType().getNonReferenceType();
1276 return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
1277 SourceLocation(), VD,
1278 /*RefersToEnclosingVariableOrCapture=*/false,
1279 Id.getLoc(), ExprType, VK_LValue);
1280}
1281
1282Sema::DeclGroupPtrTy
1283Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
1284 ArrayRef<Expr *> VarList) {
1285 if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
1286 CurContext->addDecl(D);
1287 return DeclGroupPtrTy::make(DeclGroupRef(D));
1288 }
1289 return nullptr;
1290}
1291
1292namespace {
1293class LocalVarRefChecker : public ConstStmtVisitor<LocalVarRefChecker, bool> {
1294 Sema &SemaRef;
1295
1296public:
1297 bool VisitDeclRefExpr(const DeclRefExpr *E) {
1298 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1299 if (VD->hasLocalStorage()) {
1300 SemaRef.Diag(E->getLocStart(),
1301 diag::err_omp_local_var_in_threadprivate_init)
1302 << E->getSourceRange();
1303 SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
1304 << VD << VD->getSourceRange();
1305 return true;
1306 }
1307 }
1308 return false;
1309 }
1310 bool VisitStmt(const Stmt *S) {
1311 for (auto Child : S->children()) {
1312 if (Child && Visit(Child))
1313 return true;
1314 }
1315 return false;
1316 }
1317 explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
1318};
1319} // namespace
1320
1321OMPThreadPrivateDecl *
1322Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
1323 SmallVector<Expr *, 8> Vars;
1324 for (auto &RefExpr : VarList) {
1325 DeclRefExpr *DE = cast<DeclRefExpr>(RefExpr);
1326 VarDecl *VD = cast<VarDecl>(DE->getDecl());
1327 SourceLocation ILoc = DE->getExprLoc();
1328
1329 // Mark variable as used.
1330 VD->setReferenced();
1331 VD->markUsed(Context);
1332
1333 QualType QType = VD->getType();
1334 if (QType->isDependentType() || QType->isInstantiationDependentType()) {
1335 // It will be analyzed later.
1336 Vars.push_back(DE);
1337 continue;
1338 }
1339
1340 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1341 // A threadprivate variable must not have an incomplete type.
1342 if (RequireCompleteType(ILoc, VD->getType(),
1343 diag::err_omp_threadprivate_incomplete_type)) {
1344 continue;
1345 }
1346
1347 // OpenMP [2.9.2, Restrictions, C/C++, p.10]
1348 // A threadprivate variable must not have a reference type.
1349 if (VD->getType()->isReferenceType()) {
1350 Diag(ILoc, diag::err_omp_ref_type_arg)
1351 << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
1352 bool IsDecl =
1353 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1354 Diag(VD->getLocation(),
1355 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1356 << VD;
1357 continue;
1358 }
1359
1360 // Check if this is a TLS variable. If TLS is not being supported, produce
1361 // the corresponding diagnostic.
1362 if ((VD->getTLSKind() != VarDecl::TLS_None &&
1363 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
1364 getLangOpts().OpenMPUseTLS &&
1365 getASTContext().getTargetInfo().isTLSSupported())) ||
1366 (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
1367 !VD->isLocalVarDecl())) {
1368 Diag(ILoc, diag::err_omp_var_thread_local)
1369 << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
1370 bool IsDecl =
1371 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
1372 Diag(VD->getLocation(),
1373 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
1374 << VD;
1375 continue;
1376 }
1377
1378 // Check if initial value of threadprivate variable reference variable with
1379 // local storage (it is not supported by runtime).
1380 if (auto Init = VD->getAnyInitializer()) {
1381 LocalVarRefChecker Checker(*this);
1382 if (Checker.Visit(Init))
1383 continue;
1384 }
1385
1386 Vars.push_back(RefExpr);
1387 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->addDSA(VD, DE, OMPC_threadprivate);
1388 VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
1389 Context, SourceRange(Loc, Loc)));
1390 if (auto *ML = Context.getASTMutationListener())
1391 ML->DeclarationMarkedOpenMPThreadPrivate(VD);
1392 }
1393 OMPThreadPrivateDecl *D = nullptr;
1394 if (!Vars.empty()) {
1395 D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
1396 Vars);
1397 D->setAccess(AS_public);
1398 }
1399 return D;
1400}
1401
1402static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack,
1403 const ValueDecl *D, DSAStackTy::DSAVarData DVar,
1404 bool IsLoopIterVar = false) {
1405 if (DVar.RefExpr) {
1406 SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
1407 << getOpenMPClauseName(DVar.CKind);
1408 return;
1409 }
1410 enum {
1411 PDSA_StaticMemberShared,
1412 PDSA_StaticLocalVarShared,
1413 PDSA_LoopIterVarPrivate,
1414 PDSA_LoopIterVarLinear,
1415 PDSA_LoopIterVarLastprivate,
1416 PDSA_ConstVarShared,
1417 PDSA_GlobalVarShared,
1418 PDSA_TaskVarFirstprivate,
1419 PDSA_LocalVarPrivate,
1420 PDSA_Implicit
1421 } Reason = PDSA_Implicit;
1422 bool ReportHint = false;
1423 auto ReportLoc = D->getLocation();
1424 auto *VD = dyn_cast<VarDecl>(D);
1425 if (IsLoopIterVar) {
1426 if (DVar.CKind == OMPC_private)
1427 Reason = PDSA_LoopIterVarPrivate;
1428 else if (DVar.CKind == OMPC_lastprivate)
1429 Reason = PDSA_LoopIterVarLastprivate;
1430 else
1431 Reason = PDSA_LoopIterVarLinear;
1432 } else if (isOpenMPTaskingDirective(DVar.DKind) &&
1433 DVar.CKind == OMPC_firstprivate) {
1434 Reason = PDSA_TaskVarFirstprivate;
1435 ReportLoc = DVar.ImplicitDSALoc;
1436 } else if (VD && VD->isStaticLocal())
1437 Reason = PDSA_StaticLocalVarShared;
1438 else if (VD && VD->isStaticDataMember())
1439 Reason = PDSA_StaticMemberShared;
1440 else if (VD && VD->isFileVarDecl())
1441 Reason = PDSA_GlobalVarShared;
1442 else if (D->getType().isConstant(SemaRef.getASTContext()))
1443 Reason = PDSA_ConstVarShared;
1444 else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
1445 ReportHint = true;
1446 Reason = PDSA_LocalVarPrivate;
1447 }
1448 if (Reason != PDSA_Implicit) {
1449 SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
1450 << Reason << ReportHint
1451 << getOpenMPDirectiveName(Stack->getCurrentDirective());
1452 } else if (DVar.ImplicitDSALoc.isValid()) {
1453 SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
1454 << getOpenMPClauseName(DVar.CKind);
1455 }
1456}
1457
1458namespace {
1459class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> {
1460 DSAStackTy *Stack;
1461 Sema &SemaRef;
1462 bool ErrorFound;
1463 CapturedStmt *CS;
1464 llvm::SmallVector<Expr *, 8> ImplicitFirstprivate;
1465 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
1466
1467public:
1468 void VisitDeclRefExpr(DeclRefExpr *E) {
1469 if (E->isTypeDependent() || E->isValueDependent() ||
1470 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1471 return;
1472 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
1473 // Skip internally declared variables.
1474 if (VD->isLocalVarDecl() && !CS->capturesVariable(VD))
1475 return;
1476
1477 auto DVar = Stack->getTopDSA(VD, false);
1478 // Check if the variable has explicit DSA set and stop analysis if it so.
1479 if (DVar.RefExpr)
1480 return;
1481
1482 auto ELoc = E->getExprLoc();
1483 auto DKind = Stack->getCurrentDirective();
1484 // The default(none) clause requires that each variable that is referenced
1485 // in the construct, and does not have a predetermined data-sharing
1486 // attribute, must have its data-sharing attribute explicitly determined
1487 // by being listed in a data-sharing attribute clause.
1488 if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none &&
1489 isParallelOrTaskRegion(DKind) &&
1490 VarsWithInheritedDSA.count(VD) == 0) {
1491 VarsWithInheritedDSA[VD] = E;
1492 return;
1493 }
1494
1495 // OpenMP [2.9.3.6, Restrictions, p.2]
1496 // A list item that appears in a reduction clause of the innermost
1497 // enclosing worksharing or parallel construct may not be accessed in an
1498 // explicit task.
1499 DVar = Stack->hasInnermostDSA(
1500 VD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1501 [](OpenMPDirectiveKind K) -> bool {
1502 return isOpenMPParallelDirective(K) ||
1503 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
1504 },
1505 false);
1506 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1507 ErrorFound = true;
1508 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1509 ReportOriginalDSA(SemaRef, Stack, VD, DVar);
1510 return;
1511 }
1512
1513 // Define implicit data-sharing attributes for task.
1514 DVar = Stack->getImplicitDSA(VD, false);
1515 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1516 !Stack->isLoopControlVariable(VD).first)
1517 ImplicitFirstprivate.push_back(E);
1518 }
1519 }
1520 void VisitMemberExpr(MemberExpr *E) {
1521 if (E->isTypeDependent() || E->isValueDependent() ||
1522 E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
1523 return;
1524 if (isa<CXXThisExpr>(E->getBase()->IgnoreParens())) {
1525 if (auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
1526 auto DVar = Stack->getTopDSA(FD, false);
1527 // Check if the variable has explicit DSA set and stop analysis if it
1528 // so.
1529 if (DVar.RefExpr)
1530 return;
1531
1532 auto ELoc = E->getExprLoc();
1533 auto DKind = Stack->getCurrentDirective();
1534 // OpenMP [2.9.3.6, Restrictions, p.2]
1535 // A list item that appears in a reduction clause of the innermost
1536 // enclosing worksharing or parallel construct may not be accessed in
1537 // an explicit task.
1538 DVar = Stack->hasInnermostDSA(
1539 FD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; },
1540 [](OpenMPDirectiveKind K) -> bool {
1541 return isOpenMPParallelDirective(K) ||
1542 isOpenMPWorksharingDirective(K) ||
1543 isOpenMPTeamsDirective(K);
1544 },
1545 false);
1546 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
1547 ErrorFound = true;
1548 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
1549 ReportOriginalDSA(SemaRef, Stack, FD, DVar);
1550 return;
1551 }
1552
1553 // Define implicit data-sharing attributes for task.
1554 DVar = Stack->getImplicitDSA(FD, false);
1555 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
1556 !Stack->isLoopControlVariable(FD).first)
1557 ImplicitFirstprivate.push_back(E);
1558 }
1559 } else
1560 Visit(E->getBase());
1561 }
1562 void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
1563 for (auto *C : S->clauses()) {
1564 // Skip analysis of arguments of implicitly defined firstprivate clause
1565 // for task directives.
1566 if (C && (!isa<OMPFirstprivateClause>(C) || C->getLocStart().isValid()))
1567 for (auto *CC : C->children()) {
1568 if (CC)
1569 Visit(CC);
1570 }
1571 }
1572 }
1573 void VisitStmt(Stmt *S) {
1574 for (auto *C : S->children()) {
1575 if (C && !isa<OMPExecutableDirective>(C))
1576 Visit(C);
1577 }
1578 }
1579
1580 bool isErrorFound() { return ErrorFound; }
1581 ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; }
1582 llvm::DenseMap<ValueDecl *, Expr *> &getVarsWithInheritedDSA() {
1583 return VarsWithInheritedDSA;
1584 }
1585
1586 DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
1587 : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {}
1588};
1589} // namespace
1590
1591void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
1592 switch (DKind) {
1593 case OMPD_parallel:
1594 case OMPD_parallel_for:
1595 case OMPD_parallel_for_simd:
1596 case OMPD_parallel_sections:
1597 case OMPD_teams:
1598 case OMPD_target_teams: {
1599 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1600 QualType KmpInt32PtrTy =
1601 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1602 Sema::CapturedParamNameType Params[] = {
1603 std::make_pair(".global_tid.", KmpInt32PtrTy),
1604 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1605 std::make_pair(StringRef(), QualType()) // __context with shared vars
1606 };
1607 ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getConstructLoc(), CurScope, CR_OpenMP,
1608 Params);
1609 break;
1610 }
1611 case OMPD_simd:
1612 case OMPD_for:
1613 case OMPD_for_simd:
1614 case OMPD_sections:
1615 case OMPD_section:
1616 case OMPD_single:
1617 case OMPD_master:
1618 case OMPD_critical:
1619 case OMPD_taskgroup:
1620 case OMPD_distribute:
1621 case OMPD_ordered:
1622 case OMPD_atomic:
1623 case OMPD_target_data:
1624 case OMPD_target:
1625 case OMPD_target_parallel:
1626 case OMPD_target_parallel_for:
1627 case OMPD_target_parallel_for_simd:
1628 case OMPD_target_simd: {
1629 Sema::CapturedParamNameType Params[] = {
1630 std::make_pair(StringRef(), QualType()) // __context with shared vars
1631 };
1632 ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getConstructLoc(), CurScope, CR_OpenMP,
1633 Params);
1634 break;
1635 }
1636 case OMPD_task: {
1637 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1638 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1639 FunctionProtoType::ExtProtoInfo EPI;
1640 EPI.Variadic = true;
1641 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1642 Sema::CapturedParamNameType Params[] = {
1643 std::make_pair(".global_tid.", KmpInt32Ty),
1644 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1645 std::make_pair(".privates.", Context.VoidPtrTy.withConst()),
1646 std::make_pair(".copy_fn.",
1647 Context.getPointerType(CopyFnType).withConst()),
1648 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1649 std::make_pair(StringRef(), QualType()) // __context with shared vars
1650 };
1651 ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getConstructLoc(), CurScope, CR_OpenMP,
1652 Params);
1653 // Mark this captured region as inlined, because we don't use outlined
1654 // function directly.
1655 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1656 AlwaysInlineAttr::CreateImplicit(
1657 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1658 break;
1659 }
1660 case OMPD_taskloop:
1661 case OMPD_taskloop_simd: {
1662 QualType KmpInt32Ty =
1663 Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
1664 QualType KmpUInt64Ty =
1665 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
1666 QualType KmpInt64Ty =
1667 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
1668 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()};
1669 FunctionProtoType::ExtProtoInfo EPI;
1670 EPI.Variadic = true;
1671 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
1672 Sema::CapturedParamNameType Params[] = {
1673 std::make_pair(".global_tid.", KmpInt32Ty),
1674 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)),
1675 std::make_pair(".privates.",
1676 Context.VoidPtrTy.withConst().withRestrict()),
1677 std::make_pair(
1678 ".copy_fn.",
1679 Context.getPointerType(CopyFnType).withConst().withRestrict()),
1680 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
1681 std::make_pair(".lb.", KmpUInt64Ty),
1682 std::make_pair(".ub.", KmpUInt64Ty), std::make_pair(".st.", KmpInt64Ty),
1683 std::make_pair(".liter.", KmpInt32Ty),
1684 std::make_pair(StringRef(), QualType()) // __context with shared vars
1685 };
1686 ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getConstructLoc(), CurScope, CR_OpenMP,
1687 Params);
1688 // Mark this captured region as inlined, because we don't use outlined
1689 // function directly.
1690 getCurCapturedRegion()->TheCapturedDecl->addAttr(
1691 AlwaysInlineAttr::CreateImplicit(
1692 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
1693 break;
1694 }
1695 case OMPD_distribute_parallel_for_simd:
1696 case OMPD_distribute_simd:
1697 case OMPD_distribute_parallel_for:
1698 case OMPD_teams_distribute:
1699 case OMPD_teams_distribute_simd:
1700 case OMPD_teams_distribute_parallel_for_simd:
1701 case OMPD_teams_distribute_parallel_for:
1702 case OMPD_target_teams_distribute:
1703 case OMPD_target_teams_distribute_parallel_for:
1704 case OMPD_target_teams_distribute_parallel_for_simd: {
1705 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
1706 QualType KmpInt32PtrTy =
1707 Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
1708 Sema::CapturedParamNameType Params[] = {
1709 std::make_pair(".global_tid.", KmpInt32PtrTy),
1710 std::make_pair(".bound_tid.", KmpInt32PtrTy),
1711 std::make_pair(".previous.lb.", Context.getSizeType()),
1712 std::make_pair(".previous.ub.", Context.getSizeType()),
1713 std::make_pair(StringRef(), QualType()) // __context with shared vars
1714 };
1715 ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getConstructLoc(), CurScope, CR_OpenMP,
1716 Params);
1717 break;
1718 }
1719 case OMPD_threadprivate:
1720 case OMPD_taskyield:
1721 case OMPD_barrier:
1722 case OMPD_taskwait:
1723 case OMPD_cancellation_point:
1724 case OMPD_cancel:
1725 case OMPD_flush:
1726 case OMPD_target_enter_data:
1727 case OMPD_target_exit_data:
1728 case OMPD_declare_reduction:
1729 case OMPD_declare_simd:
1730 case OMPD_declare_target:
1731 case OMPD_end_declare_target:
1732 case OMPD_target_update:
1733 llvm_unreachable("OpenMP Directive is not allowed")::llvm::llvm_unreachable_internal("OpenMP Directive is not allowed"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 1733)
;
1734 case OMPD_unknown:
1735 llvm_unreachable("Unknown OpenMP directive")::llvm::llvm_unreachable_internal("Unknown OpenMP directive",
"/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 1735)
;
1736 }
1737}
1738
1739static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id,
1740 Expr *CaptureExpr, bool WithInit,
1741 bool AsExpression) {
1742 assert(CaptureExpr)((CaptureExpr) ? static_cast<void> (0) : __assert_fail (
"CaptureExpr", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 1742, __PRETTY_FUNCTION__))
;
1743 ASTContext &C = S.getASTContext();
1744 Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
1745 QualType Ty = Init->getType();
1746 if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) {
1747 if (S.getLangOpts().CPlusPlus)
1748 Ty = C.getLValueReferenceType(Ty);
1749 else {
1750 Ty = C.getPointerType(Ty);
1751 ExprResult Res =
1752 S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init);
1753 if (!Res.isUsable())
1754 return nullptr;
1755 Init = Res.get();
1756 }
1757 WithInit = true;
1758 }
1759 auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty,
1760 CaptureExpr->getLocStart());
1761 if (!WithInit)
1762 CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C, SourceRange()));
1763 S.CurContext->addHiddenDecl(CED);
1764 S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false,
1765 /*TypeMayContainAuto=*/true);
1766 return CED;
1767}
1768
1769static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
1770 bool WithInit) {
1771 OMPCapturedExprDecl *CD;
1772 if (auto *VD = S.IsOpenMPCapturedDecl(D))
1773 CD = cast<OMPCapturedExprDecl>(VD);
1774 else
1775 CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit,
1776 /*AsExpression=*/false);
1777 return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1778 CaptureExpr->getExprLoc());
1779}
1780
1781static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) {
1782 if (!Ref) {
1783 auto *CD =
1784 buildCaptureDecl(S, &S.getASTContext().Idents.get(".capture_expr."),
1785 CaptureExpr, /*WithInit=*/true, /*AsExpression=*/true);
1786 Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
1787 CaptureExpr->getExprLoc());
1788 }
1789 ExprResult Res = Ref;
1790 if (!S.getLangOpts().CPlusPlus &&
1791 CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() &&
1792 Ref->getType()->isPointerType())
1793 Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref);
1794 if (!Res.isUsable())
1795 return ExprError();
1796 return CaptureExpr->isGLValue() ? Res : S.DefaultLvalueConversion(Res.get());
1797}
1798
1799StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
1800 ArrayRef<OMPClause *> Clauses) {
1801 if (!S.isUsable()) {
1802 ActOnCapturedRegionError();
1803 return StmtError();
1804 }
1805
1806 OMPOrderedClause *OC = nullptr;
1807 OMPScheduleClause *SC = nullptr;
1808 SmallVector<OMPLinearClause *, 4> LCs;
1809 // This is required for proper codegen.
1810 for (auto *Clause : Clauses) {
1811 if (isOpenMPPrivate(Clause->getClauseKind()) ||
1812 Clause->getClauseKind() == OMPC_copyprivate ||
1813 (getLangOpts().OpenMPUseTLS &&
1814 getASTContext().getTargetInfo().isTLSSupported() &&
1815 Clause->getClauseKind() == OMPC_copyin)) {
1816 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin);
1817 // Mark all variables in private list clauses as used in inner region.
1818 for (auto *VarRef : Clause->children()) {
1819 if (auto *E = cast_or_null<Expr>(VarRef)) {
1820 MarkDeclarationsReferencedInExpr(E);
1821 }
1822 }
1823 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setForceVarCapturing(/*V=*/false);
1824 } else if (isParallelOrTaskRegion(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective())) {
1825 // Mark all variables in private list clauses as used in inner region.
1826 // Required for proper codegen of combined directives.
1827 // TODO: add processing for other clauses.
1828 if (auto *C = OMPClauseWithPreInit::get(Clause)) {
1829 if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
1830 for (auto *D : DS->decls())
1831 MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
1832 }
1833 }
1834 if (auto *C = OMPClauseWithPostUpdate::get(Clause)) {
1835 if (auto *E = C->getPostUpdateExpr())
1836 MarkDeclarationsReferencedInExpr(E);
1837 }
1838 }
1839 if (Clause->getClauseKind() == OMPC_schedule)
1840 SC = cast<OMPScheduleClause>(Clause);
1841 else if (Clause->getClauseKind() == OMPC_ordered)
1842 OC = cast<OMPOrderedClause>(Clause);
1843 else if (Clause->getClauseKind() == OMPC_linear)
1844 LCs.push_back(cast<OMPLinearClause>(Clause));
1845 }
1846 bool ErrorFound = false;
1847 // OpenMP, 2.7.1 Loop Construct, Restrictions
1848 // The nonmonotonic modifier cannot be specified if an ordered clause is
1849 // specified.
1850 if (SC &&
1851 (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
1852 SC->getSecondScheduleModifier() ==
1853 OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
1854 OC) {
1855 Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
1856 ? SC->getFirstScheduleModifierLoc()
1857 : SC->getSecondScheduleModifierLoc(),
1858 diag::err_omp_schedule_nonmonotonic_ordered)
1859 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1860 ErrorFound = true;
1861 }
1862 if (!LCs.empty() && OC && OC->getNumForLoops()) {
1863 for (auto *C : LCs) {
1864 Diag(C->getLocStart(), diag::err_omp_linear_ordered)
1865 << SourceRange(OC->getLocStart(), OC->getLocEnd());
1866 }
1867 ErrorFound = true;
1868 }
1869 if (isOpenMPWorksharingDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective()) &&
1870 isOpenMPSimdDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective()) && OC &&
1871 OC->getNumForLoops()) {
1872 Diag(OC->getLocStart(), diag::err_omp_ordered_simd)
1873 << getOpenMPDirectiveName(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective());
1874 ErrorFound = true;
1875 }
1876 if (ErrorFound) {
1877 ActOnCapturedRegionError();
1878 return StmtError();
1879 }
1880 return ActOnCapturedRegionEnd(S.get());
1881}
1882
1883static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack,
1884 OpenMPDirectiveKind CurrentRegion,
1885 const DeclarationNameInfo &CurrentName,
1886 OpenMPDirectiveKind CancelRegion,
1887 SourceLocation StartLoc) {
1888 if (Stack->getCurScope()) {
1889 auto ParentRegion = Stack->getParentDirective();
1890 auto OffendingRegion = ParentRegion;
1891 bool NestingProhibited = false;
1892 bool CloseNesting = true;
1893 bool OrphanSeen = false;
1894 enum {
1895 NoRecommend,
1896 ShouldBeInParallelRegion,
1897 ShouldBeInOrderedRegion,
1898 ShouldBeInTargetRegion,
1899 ShouldBeInTeamsRegion
1900 } Recommend = NoRecommend;
1901 if (isOpenMPSimdDirective(ParentRegion) && CurrentRegion != OMPD_ordered) {
1902 // OpenMP [2.16, Nesting of Regions]
1903 // OpenMP constructs may not be nested inside a simd region.
1904 // OpenMP [2.8.1,simd Construct, Restrictions]
1905 // An ordered construct with the simd clause is the only OpenMP
1906 // construct that can appear in the simd region.
1907 // Allowing a SIMD construct nested in another SIMD construct is an
1908 // extension. The OpenMP 4.5 spec does not allow it. Issue a warning
1909 // message.
1910 SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd)
1911 ? diag::err_omp_prohibited_region_simd
1912 : diag::warn_omp_nesting_simd);
1913 return CurrentRegion != OMPD_simd;
1914 }
1915 if (ParentRegion == OMPD_atomic) {
1916 // OpenMP [2.16, Nesting of Regions]
1917 // OpenMP constructs may not be nested inside an atomic region.
1918 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic);
1919 return true;
1920 }
1921 if (CurrentRegion == OMPD_section) {
1922 // OpenMP [2.7.2, sections Construct, Restrictions]
1923 // Orphaned section directives are prohibited. That is, the section
1924 // directives must appear within the sections construct and must not be
1925 // encountered elsewhere in the sections region.
1926 if (ParentRegion != OMPD_sections &&
1927 ParentRegion != OMPD_parallel_sections) {
1928 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
1929 << (ParentRegion != OMPD_unknown)
1930 << getOpenMPDirectiveName(ParentRegion);
1931 return true;
1932 }
1933 return false;
1934 }
1935 // Allow some constructs (except teams) to be orphaned (they could be
1936 // used in functions, called from OpenMP regions with the required
1937 // preconditions).
1938 if (ParentRegion == OMPD_unknown &&
1939 !isOpenMPNestingTeamsDirective(CurrentRegion))
1940 return false;
1941 if (CurrentRegion == OMPD_cancellation_point ||
1942 CurrentRegion == OMPD_cancel) {
1943 // OpenMP [2.16, Nesting of Regions]
1944 // A cancellation point construct for which construct-type-clause is
1945 // taskgroup must be nested inside a task construct. A cancellation
1946 // point construct for which construct-type-clause is not taskgroup must
1947 // be closely nested inside an OpenMP construct that matches the type
1948 // specified in construct-type-clause.
1949 // A cancel construct for which construct-type-clause is taskgroup must be
1950 // nested inside a task construct. A cancel construct for which
1951 // construct-type-clause is not taskgroup must be closely nested inside an
1952 // OpenMP construct that matches the type specified in
1953 // construct-type-clause.
1954 NestingProhibited =
1955 !((CancelRegion == OMPD_parallel &&
1956 (ParentRegion == OMPD_parallel ||
1957 ParentRegion == OMPD_target_parallel)) ||
1958 (CancelRegion == OMPD_for &&
1959 (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for ||
1960 ParentRegion == OMPD_target_parallel_for)) ||
1961 (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) ||
1962 (CancelRegion == OMPD_sections &&
1963 (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
1964 ParentRegion == OMPD_parallel_sections)));
1965 } else if (CurrentRegion == OMPD_master) {
1966 // OpenMP [2.16, Nesting of Regions]
1967 // A master region may not be closely nested inside a worksharing,
1968 // atomic, or explicit task region.
1969 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
1970 isOpenMPTaskingDirective(ParentRegion);
1971 } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
1972 // OpenMP [2.16, Nesting of Regions]
1973 // A critical region may not be nested (closely or otherwise) inside a
1974 // critical region with the same name. Note that this restriction is not
1975 // sufficient to prevent deadlock.
1976 SourceLocation PreviousCriticalLoc;
1977 bool DeadLock = Stack->hasDirective(
1978 [CurrentName, &PreviousCriticalLoc](OpenMPDirectiveKind K,
1979 const DeclarationNameInfo &DNI,
1980 SourceLocation Loc) -> bool {
1981 if (K == OMPD_critical && DNI.getName() == CurrentName.getName()) {
1982 PreviousCriticalLoc = Loc;
1983 return true;
1984 } else
1985 return false;
1986 },
1987 false /* skip top directive */);
1988 if (DeadLock) {
1989 SemaRef.Diag(StartLoc,
1990 diag::err_omp_prohibited_region_critical_same_name)
1991 << CurrentName.getName();
1992 if (PreviousCriticalLoc.isValid())
1993 SemaRef.Diag(PreviousCriticalLoc,
1994 diag::note_omp_previous_critical_region);
1995 return true;
1996 }
1997 } else if (CurrentRegion == OMPD_barrier) {
1998 // OpenMP [2.16, Nesting of Regions]
1999 // A barrier region may not be closely nested inside a worksharing,
2000 // explicit task, critical, ordered, atomic, or master region.
2001 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2002 isOpenMPTaskingDirective(ParentRegion) ||
2003 ParentRegion == OMPD_master ||
2004 ParentRegion == OMPD_critical ||
2005 ParentRegion == OMPD_ordered;
2006 } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
2007 !isOpenMPParallelDirective(CurrentRegion) &&
2008 !isOpenMPTeamsDirective(CurrentRegion)) {
2009 // OpenMP [2.16, Nesting of Regions]
2010 // A worksharing region may not be closely nested inside a worksharing,
2011 // explicit task, critical, ordered, atomic, or master region.
2012 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
2013 isOpenMPTaskingDirective(ParentRegion) ||
2014 ParentRegion == OMPD_master ||
2015 ParentRegion == OMPD_critical ||
2016 ParentRegion == OMPD_ordered;
2017 Recommend = ShouldBeInParallelRegion;
2018 } else if (CurrentRegion == OMPD_ordered) {
2019 // OpenMP [2.16, Nesting of Regions]
2020 // An ordered region may not be closely nested inside a critical,
2021 // atomic, or explicit task region.
2022 // An ordered region must be closely nested inside a loop region (or
2023 // parallel loop region) with an ordered clause.
2024 // OpenMP [2.8.1,simd Construct, Restrictions]
2025 // An ordered construct with the simd clause is the only OpenMP construct
2026 // that can appear in the simd region.
2027 NestingProhibited = ParentRegion == OMPD_critical ||
2028 isOpenMPTaskingDirective(ParentRegion) ||
2029 !(isOpenMPSimdDirective(ParentRegion) ||
2030 Stack->isParentOrderedRegion());
2031 Recommend = ShouldBeInOrderedRegion;
2032 } else if (isOpenMPNestingTeamsDirective(CurrentRegion)) {
2033 // OpenMP [2.16, Nesting of Regions]
2034 // If specified, a teams construct must be contained within a target
2035 // construct.
2036 NestingProhibited = ParentRegion != OMPD_target;
2037 OrphanSeen = ParentRegion == OMPD_unknown;
2038 Recommend = ShouldBeInTargetRegion;
2039 Stack->setParentTeamsRegionLoc(Stack->getConstructLoc());
2040 }
2041 if (!NestingProhibited &&
2042 !isOpenMPTargetExecutionDirective(CurrentRegion) &&
2043 !isOpenMPTargetDataManagementDirective(CurrentRegion) &&
2044 (ParentRegion == OMPD_teams || ParentRegion == OMPD_target_teams)) {
2045 // OpenMP [2.16, Nesting of Regions]
2046 // distribute, parallel, parallel sections, parallel workshare, and the
2047 // parallel loop and parallel loop SIMD constructs are the only OpenMP
2048 // constructs that can be closely nested in the teams region.
2049 NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) &&
2050 !isOpenMPDistributeDirective(CurrentRegion);
2051 Recommend = ShouldBeInParallelRegion;
2052 }
2053 if (!NestingProhibited &&
2054 isOpenMPNestingDistributeDirective(CurrentRegion)) {
2055 // OpenMP 4.5 [2.17 Nesting of Regions]
2056 // The region associated with the distribute construct must be strictly
2057 // nested inside a teams region
2058 NestingProhibited =
2059 (ParentRegion != OMPD_teams && ParentRegion != OMPD_target_teams);
2060 Recommend = ShouldBeInTeamsRegion;
2061 }
2062 if (!NestingProhibited &&
2063 (isOpenMPTargetExecutionDirective(CurrentRegion) ||
2064 isOpenMPTargetDataManagementDirective(CurrentRegion))) {
2065 // OpenMP 4.5 [2.17 Nesting of Regions]
2066 // If a target, target update, target data, target enter data, or
2067 // target exit data construct is encountered during execution of a
2068 // target region, the behavior is unspecified.
2069 NestingProhibited = Stack->hasDirective(
2070 [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &,
2071 SourceLocation) -> bool {
2072 if (isOpenMPTargetExecutionDirective(K)) {
2073 OffendingRegion = K;
2074 return true;
2075 } else
2076 return false;
2077 },
2078 false /* don't skip top directive */);
2079 CloseNesting = false;
2080 }
2081 if (NestingProhibited) {
2082 if (OrphanSeen) {
2083 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_device_directive)
2084 << getOpenMPDirectiveName(CurrentRegion) << Recommend;
2085 } else {
2086 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region)
2087 << CloseNesting << getOpenMPDirectiveName(OffendingRegion)
2088 << Recommend << getOpenMPDirectiveName(CurrentRegion);
2089 }
2090 return true;
2091 }
2092 }
2093 return false;
2094}
2095
2096static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
2097 ArrayRef<OMPClause *> Clauses,
2098 ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
2099 bool ErrorFound = false;
2100 unsigned NamedModifiersNumber = 0;
2101 SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers(
2102 OMPD_unknown + 1);
2103 SmallVector<SourceLocation, 4> NameModifierLoc;
2104 for (const auto *C : Clauses) {
2105 if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {
2106 // At most one if clause without a directive-name-modifier can appear on
2107 // the directive.
2108 OpenMPDirectiveKind CurNM = IC->getNameModifier();
2109 if (FoundNameModifiers[CurNM]) {
2110 S.Diag(C->getLocStart(), diag::err_omp_more_one_clause)
2111 << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if)
2112 << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM);
2113 ErrorFound = true;
2114 } else if (CurNM != OMPD_unknown) {
2115 NameModifierLoc.push_back(IC->getNameModifierLoc());
2116 ++NamedModifiersNumber;
2117 }
2118 FoundNameModifiers[CurNM] = IC;
2119 if (CurNM == OMPD_unknown)
2120 continue;
2121 // Check if the specified name modifier is allowed for the current
2122 // directive.
2123 // At most one if clause with the particular directive-name-modifier can
2124 // appear on the directive.
2125 bool MatchFound = false;
2126 for (auto NM : AllowedNameModifiers) {
2127 if (CurNM == NM) {
2128 MatchFound = true;
2129 break;
2130 }
2131 }
2132 if (!MatchFound) {
2133 S.Diag(IC->getNameModifierLoc(),
2134 diag::err_omp_wrong_if_directive_name_modifier)
2135 << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind);
2136 ErrorFound = true;
2137 }
2138 }
2139 }
2140 // If any if clause on the directive includes a directive-name-modifier then
2141 // all if clauses on the directive must include a directive-name-modifier.
2142 if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {
2143 if (NamedModifiersNumber == AllowedNameModifiers.size()) {
2144 S.Diag(FoundNameModifiers[OMPD_unknown]->getLocStart(),
2145 diag::err_omp_no_more_if_clause);
2146 } else {
2147 std::string Values;
2148 std::string Sep(", ");
2149 unsigned AllowedCnt = 0;
2150 unsigned TotalAllowedNum =
2151 AllowedNameModifiers.size() - NamedModifiersNumber;
2152 for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End;
2153 ++Cnt) {
2154 OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt];
2155 if (!FoundNameModifiers[NM]) {
2156 Values += "'";
2157 Values += getOpenMPDirectiveName(NM);
2158 Values += "'";
2159 if (AllowedCnt + 2 == TotalAllowedNum)
2160 Values += " or ";
2161 else if (AllowedCnt + 1 != TotalAllowedNum)
2162 Values += Sep;
2163 ++AllowedCnt;
2164 }
2165 }
2166 S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getLocStart(),
2167 diag::err_omp_unnamed_if_clause)
2168 << (TotalAllowedNum > 1) << Values;
2169 }
2170 for (auto Loc : NameModifierLoc) {
2171 S.Diag(Loc, diag::note_omp_previous_named_if_clause);
2172 }
2173 ErrorFound = true;
2174 }
2175 return ErrorFound;
2176}
2177
2178StmtResult Sema::ActOnOpenMPExecutableDirective(
2179 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
2180 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
2181 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
2182 StmtResult Res = StmtError();
2183 if (CheckNestingOfRegions(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, Kind, DirName, CancelRegion,
2184 StartLoc))
2185 return StmtError();
2186
2187 llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
2188 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA;
2189 bool ErrorFound = false;
2190 ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
2191 if (AStmt) {
2192 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2192, __PRETTY_FUNCTION__))
;
2193
2194 // Check default data sharing attributes for referenced variables.
2195 DSAAttrChecker DSAChecker(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, *this, cast<CapturedStmt>(AStmt));
2196 DSAChecker.Visit(cast<CapturedStmt>(AStmt)->getCapturedStmt());
2197 if (DSAChecker.isErrorFound())
2198 return StmtError();
2199 // Generate list of implicitly defined firstprivate variables.
2200 VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA();
2201
2202 if (!DSAChecker.getImplicitFirstprivate().empty()) {
2203 if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause(
2204 DSAChecker.getImplicitFirstprivate(), SourceLocation(),
2205 SourceLocation(), SourceLocation())) {
2206 ClausesWithImplicit.push_back(Implicit);
2207 ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() !=
2208 DSAChecker.getImplicitFirstprivate().size();
2209 } else
2210 ErrorFound = true;
2211 }
2212 }
2213
2214 llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
2215 switch (Kind) {
2216 case OMPD_parallel:
2217 Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
2218 EndLoc);
2219 AllowedNameModifiers.push_back(OMPD_parallel);
2220 break;
2221 case OMPD_simd:
2222 Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
2223 VarsWithInheritedDSA);
2224 break;
2225 case OMPD_for:
2226 Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
2227 VarsWithInheritedDSA);
2228 break;
2229 case OMPD_for_simd:
2230 Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2231 EndLoc, VarsWithInheritedDSA);
2232 break;
2233 case OMPD_sections:
2234 Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
2235 EndLoc);
2236 break;
2237 case OMPD_section:
2238 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp section' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp section' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2239, __PRETTY_FUNCTION__))
2239 "No clauses are allowed for 'omp section' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp section' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp section' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2239, __PRETTY_FUNCTION__))
;
2240 Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
2241 break;
2242 case OMPD_single:
2243 Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
2244 EndLoc);
2245 break;
2246 case OMPD_master:
2247 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp master' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp master' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2248, __PRETTY_FUNCTION__))
2248 "No clauses are allowed for 'omp master' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp master' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp master' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2248, __PRETTY_FUNCTION__))
;
2249 Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
2250 break;
2251 case OMPD_critical:
2252 Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt,
2253 StartLoc, EndLoc);
2254 break;
2255 case OMPD_parallel_for:
2256 Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc,
2257 EndLoc, VarsWithInheritedDSA);
2258 AllowedNameModifiers.push_back(OMPD_parallel);
2259 break;
2260 case OMPD_parallel_for_simd:
2261 Res = ActOnOpenMPParallelForSimdDirective(
2262 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2263 AllowedNameModifiers.push_back(OMPD_parallel);
2264 break;
2265 case OMPD_parallel_sections:
2266 Res = ActOnOpenMPParallelSectionsDirective(ClausesWithImplicit, AStmt,
2267 StartLoc, EndLoc);
2268 AllowedNameModifiers.push_back(OMPD_parallel);
2269 break;
2270 case OMPD_task:
2271 Res =
2272 ActOnOpenMPTaskDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
2273 AllowedNameModifiers.push_back(OMPD_task);
2274 break;
2275 case OMPD_taskyield:
2276 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp taskyield' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp taskyield' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2277, __PRETTY_FUNCTION__))
2277 "No clauses are allowed for 'omp taskyield' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp taskyield' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp taskyield' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2277, __PRETTY_FUNCTION__))
;
2278 assert(AStmt == nullptr &&((AStmt == nullptr && "No associated statement allowed for 'omp taskyield' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp taskyield' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2279, __PRETTY_FUNCTION__))
2279 "No associated statement allowed for 'omp taskyield' directive")((AStmt == nullptr && "No associated statement allowed for 'omp taskyield' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp taskyield' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2279, __PRETTY_FUNCTION__))
;
2280 Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc);
2281 break;
2282 case OMPD_barrier:
2283 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp barrier' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp barrier' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2284, __PRETTY_FUNCTION__))
2284 "No clauses are allowed for 'omp barrier' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp barrier' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp barrier' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2284, __PRETTY_FUNCTION__))
;
2285 assert(AStmt == nullptr &&((AStmt == nullptr && "No associated statement allowed for 'omp barrier' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp barrier' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2286, __PRETTY_FUNCTION__))
2286 "No associated statement allowed for 'omp barrier' directive")((AStmt == nullptr && "No associated statement allowed for 'omp barrier' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp barrier' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2286, __PRETTY_FUNCTION__))
;
2287 Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
2288 break;
2289 case OMPD_taskwait:
2290 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp taskwait' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp taskwait' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2291, __PRETTY_FUNCTION__))
2291 "No clauses are allowed for 'omp taskwait' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp taskwait' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp taskwait' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2291, __PRETTY_FUNCTION__))
;
2292 assert(AStmt == nullptr &&((AStmt == nullptr && "No associated statement allowed for 'omp taskwait' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp taskwait' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2293, __PRETTY_FUNCTION__))
2293 "No associated statement allowed for 'omp taskwait' directive")((AStmt == nullptr && "No associated statement allowed for 'omp taskwait' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp taskwait' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2293, __PRETTY_FUNCTION__))
;
2294 Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc);
2295 break;
2296 case OMPD_taskgroup:
2297 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp taskgroup' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp taskgroup' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2298, __PRETTY_FUNCTION__))
2298 "No clauses are allowed for 'omp taskgroup' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp taskgroup' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp taskgroup' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2298, __PRETTY_FUNCTION__))
;
2299 Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc);
2300 break;
2301 case OMPD_flush:
2302 assert(AStmt == nullptr &&((AStmt == nullptr && "No associated statement allowed for 'omp flush' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp flush' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2303, __PRETTY_FUNCTION__))
2303 "No associated statement allowed for 'omp flush' directive")((AStmt == nullptr && "No associated statement allowed for 'omp flush' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp flush' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2303, __PRETTY_FUNCTION__))
;
2304 Res = ActOnOpenMPFlushDirective(ClausesWithImplicit, StartLoc, EndLoc);
2305 break;
2306 case OMPD_ordered:
2307 Res = ActOnOpenMPOrderedDirective(ClausesWithImplicit, AStmt, StartLoc,
2308 EndLoc);
2309 break;
2310 case OMPD_atomic:
2311 Res = ActOnOpenMPAtomicDirective(ClausesWithImplicit, AStmt, StartLoc,
2312 EndLoc);
2313 break;
2314 case OMPD_teams:
2315 Res =
2316 ActOnOpenMPTeamsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
2317 break;
2318 case OMPD_target:
2319 Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc,
2320 EndLoc);
2321 AllowedNameModifiers.push_back(OMPD_target);
2322 break;
2323 case OMPD_target_parallel:
2324 Res = ActOnOpenMPTargetParallelDirective(ClausesWithImplicit, AStmt,
2325 StartLoc, EndLoc);
2326 AllowedNameModifiers.push_back(OMPD_target);
2327 AllowedNameModifiers.push_back(OMPD_parallel);
2328 break;
2329 case OMPD_target_parallel_for:
2330 Res = ActOnOpenMPTargetParallelForDirective(
2331 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2332 AllowedNameModifiers.push_back(OMPD_target);
2333 AllowedNameModifiers.push_back(OMPD_parallel);
2334 break;
2335 case OMPD_cancellation_point:
2336 assert(ClausesWithImplicit.empty() &&((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp cancellation point' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp cancellation point' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2337, __PRETTY_FUNCTION__))
2337 "No clauses are allowed for 'omp cancellation point' directive")((ClausesWithImplicit.empty() && "No clauses are allowed for 'omp cancellation point' directive"
) ? static_cast<void> (0) : __assert_fail ("ClausesWithImplicit.empty() && \"No clauses are allowed for 'omp cancellation point' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2337, __PRETTY_FUNCTION__))
;
2338 assert(AStmt == nullptr && "No associated statement allowed for 'omp "((AStmt == nullptr && "No associated statement allowed for 'omp "
"cancellation point' directive") ? static_cast<void> (
0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp \" \"cancellation point' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2339, __PRETTY_FUNCTION__))
2339 "cancellation point' directive")((AStmt == nullptr && "No associated statement allowed for 'omp "
"cancellation point' directive") ? static_cast<void> (
0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp \" \"cancellation point' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2339, __PRETTY_FUNCTION__))
;
2340 Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion);
2341 break;
2342 case OMPD_cancel:
2343 assert(AStmt == nullptr &&((AStmt == nullptr && "No associated statement allowed for 'omp cancel' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp cancel' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2344, __PRETTY_FUNCTION__))
2344 "No associated statement allowed for 'omp cancel' directive")((AStmt == nullptr && "No associated statement allowed for 'omp cancel' directive"
) ? static_cast<void> (0) : __assert_fail ("AStmt == nullptr && \"No associated statement allowed for 'omp cancel' directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2344, __PRETTY_FUNCTION__))
;
2345 Res = ActOnOpenMPCancelDirective(ClausesWithImplicit, StartLoc, EndLoc,
2346 CancelRegion);
2347 AllowedNameModifiers.push_back(OMPD_cancel);
2348 break;
2349 case OMPD_target_data:
2350 Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc,
2351 EndLoc);
2352 AllowedNameModifiers.push_back(OMPD_target_data);
2353 break;
2354 case OMPD_target_enter_data:
2355 Res = ActOnOpenMPTargetEnterDataDirective(ClausesWithImplicit, StartLoc,
2356 EndLoc);
2357 AllowedNameModifiers.push_back(OMPD_target_enter_data);
2358 break;
2359 case OMPD_target_exit_data:
2360 Res = ActOnOpenMPTargetExitDataDirective(ClausesWithImplicit, StartLoc,
2361 EndLoc);
2362 AllowedNameModifiers.push_back(OMPD_target_exit_data);
2363 break;
2364 case OMPD_taskloop:
2365 Res = ActOnOpenMPTaskLoopDirective(ClausesWithImplicit, AStmt, StartLoc,
2366 EndLoc, VarsWithInheritedDSA);
2367 AllowedNameModifiers.push_back(OMPD_taskloop);
2368 break;
2369 case OMPD_taskloop_simd:
2370 Res = ActOnOpenMPTaskLoopSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2371 EndLoc, VarsWithInheritedDSA);
2372 AllowedNameModifiers.push_back(OMPD_taskloop);
2373 break;
2374 case OMPD_distribute:
2375 Res = ActOnOpenMPDistributeDirective(ClausesWithImplicit, AStmt, StartLoc,
2376 EndLoc, VarsWithInheritedDSA);
2377 break;
2378 case OMPD_target_update:
2379 assert(!AStmt && "Statement is not allowed for target update")((!AStmt && "Statement is not allowed for target update"
) ? static_cast<void> (0) : __assert_fail ("!AStmt && \"Statement is not allowed for target update\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2379, __PRETTY_FUNCTION__))
;
2380 Res =
2381 ActOnOpenMPTargetUpdateDirective(ClausesWithImplicit, StartLoc, EndLoc);
2382 AllowedNameModifiers.push_back(OMPD_target_update);
2383 break;
2384 case OMPD_distribute_parallel_for:
2385 Res = ActOnOpenMPDistributeParallelForDirective(
2386 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2387 AllowedNameModifiers.push_back(OMPD_parallel);
2388 break;
2389 case OMPD_distribute_parallel_for_simd:
2390 Res = ActOnOpenMPDistributeParallelForSimdDirective(
2391 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2392 AllowedNameModifiers.push_back(OMPD_parallel);
2393 break;
2394 case OMPD_distribute_simd:
2395 Res = ActOnOpenMPDistributeSimdDirective(
2396 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2397 break;
2398 case OMPD_target_parallel_for_simd:
2399 Res = ActOnOpenMPTargetParallelForSimdDirective(
2400 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2401 AllowedNameModifiers.push_back(OMPD_target);
2402 AllowedNameModifiers.push_back(OMPD_parallel);
2403 break;
2404 case OMPD_target_simd:
2405 Res = ActOnOpenMPTargetSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
2406 EndLoc, VarsWithInheritedDSA);
2407 AllowedNameModifiers.push_back(OMPD_target);
2408 break;
2409 case OMPD_teams_distribute:
2410 Res = ActOnOpenMPTeamsDistributeDirective(
2411 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2412 break;
2413 case OMPD_teams_distribute_simd:
2414 Res = ActOnOpenMPTeamsDistributeSimdDirective(
2415 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2416 break;
2417 case OMPD_teams_distribute_parallel_for_simd:
2418 Res = ActOnOpenMPTeamsDistributeParallelForSimdDirective(
2419 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2420 AllowedNameModifiers.push_back(OMPD_parallel);
2421 break;
2422 case OMPD_teams_distribute_parallel_for:
2423 Res = ActOnOpenMPTeamsDistributeParallelForDirective(
2424 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2425 AllowedNameModifiers.push_back(OMPD_parallel);
2426 break;
2427 case OMPD_target_teams:
2428 Res = ActOnOpenMPTargetTeamsDirective(ClausesWithImplicit, AStmt, StartLoc,
2429 EndLoc);
2430 AllowedNameModifiers.push_back(OMPD_target);
2431 break;
2432 case OMPD_target_teams_distribute:
2433 Res = ActOnOpenMPTargetTeamsDistributeDirective(
2434 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2435 AllowedNameModifiers.push_back(OMPD_target);
2436 break;
2437 case OMPD_target_teams_distribute_parallel_for:
2438 Res = ActOnOpenMPTargetTeamsDistributeParallelForDirective(
2439 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2440 AllowedNameModifiers.push_back(OMPD_target);
2441 AllowedNameModifiers.push_back(OMPD_parallel);
2442 break;
2443 case OMPD_target_teams_distribute_parallel_for_simd:
2444 Res = ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
2445 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
2446 AllowedNameModifiers.push_back(OMPD_target);
2447 AllowedNameModifiers.push_back(OMPD_parallel);
2448 break;
2449 case OMPD_declare_target:
2450 case OMPD_end_declare_target:
2451 case OMPD_threadprivate:
2452 case OMPD_declare_reduction:
2453 case OMPD_declare_simd:
2454 llvm_unreachable("OpenMP Directive is not allowed")::llvm::llvm_unreachable_internal("OpenMP Directive is not allowed"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2454)
;
2455 case OMPD_unknown:
2456 llvm_unreachable("Unknown OpenMP directive")::llvm::llvm_unreachable_internal("Unknown OpenMP directive",
"/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2456)
;
2457 }
2458
2459 for (auto P : VarsWithInheritedDSA) {
2460 Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
2461 << P.first << P.second->getSourceRange();
2462 }
2463 ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound;
2464
2465 if (!AllowedNameModifiers.empty())
2466 ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) ||
2467 ErrorFound;
2468
2469 if (ErrorFound)
2470 return StmtError();
2471 return Res;
2472}
2473
2474Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
2475 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
2476 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
2477 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
2478 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
2479 assert(Aligneds.size() == Alignments.size())((Aligneds.size() == Alignments.size()) ? static_cast<void
> (0) : __assert_fail ("Aligneds.size() == Alignments.size()"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2479, __PRETTY_FUNCTION__))
;
2480 assert(Linears.size() == LinModifiers.size())((Linears.size() == LinModifiers.size()) ? static_cast<void
> (0) : __assert_fail ("Linears.size() == LinModifiers.size()"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2480, __PRETTY_FUNCTION__))
;
2481 assert(Linears.size() == Steps.size())((Linears.size() == Steps.size()) ? static_cast<void> (
0) : __assert_fail ("Linears.size() == Steps.size()", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2481, __PRETTY_FUNCTION__))
;
2482 if (!DG || DG.get().isNull())
2483 return DeclGroupPtrTy();
2484
2485 if (!DG.get().isSingleDecl()) {
2486 Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd);
2487 return DG;
2488 }
2489 auto *ADecl = DG.get().getSingleDecl();
2490 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
2491 ADecl = FTD->getTemplatedDecl();
2492
2493 auto *FD = dyn_cast<FunctionDecl>(ADecl);
2494 if (!FD) {
2495 Diag(ADecl->getLocation(), diag::err_omp_function_expected);
2496 return DeclGroupPtrTy();
2497 }
2498
2499 // OpenMP [2.8.2, declare simd construct, Description]
2500 // The parameter of the simdlen clause must be a constant positive integer
2501 // expression.
2502 ExprResult SL;
2503 if (Simdlen)
2504 SL = VerifyPositiveIntegerConstantInClause(Simdlen, OMPC_simdlen);
2505 // OpenMP [2.8.2, declare simd construct, Description]
2506 // The special this pointer can be used as if was one of the arguments to the
2507 // function in any of the linear, aligned, or uniform clauses.
2508 // The uniform clause declares one or more arguments to have an invariant
2509 // value for all concurrent invocations of the function in the execution of a
2510 // single SIMD loop.
2511 llvm::DenseMap<Decl *, Expr *> UniformedArgs;
2512 Expr *UniformedLinearThis = nullptr;
2513 for (auto *E : Uniforms) {
2514 E = E->IgnoreParenImpCasts();
2515 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2516 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
2517 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2518 FD->getParamDecl(PVD->getFunctionScopeIndex())
2519 ->getCanonicalDecl() == PVD->getCanonicalDecl()) {
2520 UniformedArgs.insert(std::make_pair(PVD->getCanonicalDecl(), E));
2521 continue;
2522 }
2523 if (isa<CXXThisExpr>(E)) {
2524 UniformedLinearThis = E;
2525 continue;
2526 }
2527 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2528 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2529 }
2530 // OpenMP [2.8.2, declare simd construct, Description]
2531 // The aligned clause declares that the object to which each list item points
2532 // is aligned to the number of bytes expressed in the optional parameter of
2533 // the aligned clause.
2534 // The special this pointer can be used as if was one of the arguments to the
2535 // function in any of the linear, aligned, or uniform clauses.
2536 // The type of list items appearing in the aligned clause must be array,
2537 // pointer, reference to array, or reference to pointer.
2538 llvm::DenseMap<Decl *, Expr *> AlignedArgs;
2539 Expr *AlignedThis = nullptr;
2540 for (auto *E : Aligneds) {
2541 E = E->IgnoreParenImpCasts();
2542 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2543 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2544 auto *CanonPVD = PVD->getCanonicalDecl();
2545 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2546 FD->getParamDecl(PVD->getFunctionScopeIndex())
2547 ->getCanonicalDecl() == CanonPVD) {
2548 // OpenMP [2.8.1, simd construct, Restrictions]
2549 // A list-item cannot appear in more than one aligned clause.
2550 if (AlignedArgs.count(CanonPVD) > 0) {
2551 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
2552 << 1 << E->getSourceRange();
2553 Diag(AlignedArgs[CanonPVD]->getExprLoc(),
2554 diag::note_omp_explicit_dsa)
2555 << getOpenMPClauseName(OMPC_aligned);
2556 continue;
2557 }
2558 AlignedArgs[CanonPVD] = E;
2559 QualType QTy = PVD->getType()
2560 .getNonReferenceType()
2561 .getUnqualifiedType()
2562 .getCanonicalType();
2563 const Type *Ty = QTy.getTypePtrOrNull();
2564 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) {
2565 Diag(E->getExprLoc(), diag::err_omp_aligned_expected_array_or_ptr)
2566 << QTy << getLangOpts().CPlusPlus << E->getSourceRange();
2567 Diag(PVD->getLocation(), diag::note_previous_decl) << PVD;
2568 }
2569 continue;
2570 }
2571 }
2572 if (isa<CXXThisExpr>(E)) {
2573 if (AlignedThis) {
2574 Diag(E->getExprLoc(), diag::err_omp_aligned_twice)
2575 << 2 << E->getSourceRange();
2576 Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa)
2577 << getOpenMPClauseName(OMPC_aligned);
2578 }
2579 AlignedThis = E;
2580 continue;
2581 }
2582 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2583 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2584 }
2585 // The optional parameter of the aligned clause, alignment, must be a constant
2586 // positive integer expression. If no optional parameter is specified,
2587 // implementation-defined default alignments for SIMD instructions on the
2588 // target platforms are assumed.
2589 SmallVector<Expr *, 4> NewAligns;
2590 for (auto *E : Alignments) {
2591 ExprResult Align;
2592 if (E)
2593 Align = VerifyPositiveIntegerConstantInClause(E, OMPC_aligned);
2594 NewAligns.push_back(Align.get());
2595 }
2596 // OpenMP [2.8.2, declare simd construct, Description]
2597 // The linear clause declares one or more list items to be private to a SIMD
2598 // lane and to have a linear relationship with respect to the iteration space
2599 // of a loop.
2600 // The special this pointer can be used as if was one of the arguments to the
2601 // function in any of the linear, aligned, or uniform clauses.
2602 // When a linear-step expression is specified in a linear clause it must be
2603 // either a constant integer expression or an integer-typed parameter that is
2604 // specified in a uniform clause on the directive.
2605 llvm::DenseMap<Decl *, Expr *> LinearArgs;
2606 const bool IsUniformedThis = UniformedLinearThis != nullptr;
2607 auto MI = LinModifiers.begin();
2608 for (auto *E : Linears) {
2609 auto LinKind = static_cast<OpenMPLinearClauseKind>(*MI);
2610 ++MI;
2611 E = E->IgnoreParenImpCasts();
2612 if (auto *DRE = dyn_cast<DeclRefExpr>(E))
2613 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2614 auto *CanonPVD = PVD->getCanonicalDecl();
2615 if (FD->getNumParams() > PVD->getFunctionScopeIndex() &&
2616 FD->getParamDecl(PVD->getFunctionScopeIndex())
2617 ->getCanonicalDecl() == CanonPVD) {
2618 // OpenMP [2.15.3.7, linear Clause, Restrictions]
2619 // A list-item cannot appear in more than one linear clause.
2620 if (LinearArgs.count(CanonPVD) > 0) {
2621 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2622 << getOpenMPClauseName(OMPC_linear)
2623 << getOpenMPClauseName(OMPC_linear) << E->getSourceRange();
2624 Diag(LinearArgs[CanonPVD]->getExprLoc(),
2625 diag::note_omp_explicit_dsa)
2626 << getOpenMPClauseName(OMPC_linear);
2627 continue;
2628 }
2629 // Each argument can appear in at most one uniform or linear clause.
2630 if (UniformedArgs.count(CanonPVD) > 0) {
2631 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2632 << getOpenMPClauseName(OMPC_linear)
2633 << getOpenMPClauseName(OMPC_uniform) << E->getSourceRange();
2634 Diag(UniformedArgs[CanonPVD]->getExprLoc(),
2635 diag::note_omp_explicit_dsa)
2636 << getOpenMPClauseName(OMPC_uniform);
2637 continue;
2638 }
2639 LinearArgs[CanonPVD] = E;
2640 if (E->isValueDependent() || E->isTypeDependent() ||
2641 E->isInstantiationDependent() ||
2642 E->containsUnexpandedParameterPack())
2643 continue;
2644 (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind,
2645 PVD->getOriginalType());
2646 continue;
2647 }
2648 }
2649 if (isa<CXXThisExpr>(E)) {
2650 if (UniformedLinearThis) {
2651 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
2652 << getOpenMPClauseName(OMPC_linear)
2653 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear)
2654 << E->getSourceRange();
2655 Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa)
2656 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform
2657 : OMPC_linear);
2658 continue;
2659 }
2660 UniformedLinearThis = E;
2661 if (E->isValueDependent() || E->isTypeDependent() ||
2662 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
2663 continue;
2664 (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind,
2665 E->getType());
2666 continue;
2667 }
2668 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
2669 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
2670 }
2671 Expr *Step = nullptr;
2672 Expr *NewStep = nullptr;
2673 SmallVector<Expr *, 4> NewSteps;
2674 for (auto *E : Steps) {
2675 // Skip the same step expression, it was checked already.
2676 if (Step == E || !E) {
2677 NewSteps.push_back(E ? NewStep : nullptr);
2678 continue;
2679 }
2680 Step = E;
2681 if (auto *DRE = dyn_cast<DeclRefExpr>(Step))
2682 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2683 auto *CanonPVD = PVD->getCanonicalDecl();
2684 if (UniformedArgs.count(CanonPVD) == 0) {
2685 Diag(Step->getExprLoc(), diag::err_omp_expected_uniform_param)
2686 << Step->getSourceRange();
2687 } else if (E->isValueDependent() || E->isTypeDependent() ||
2688 E->isInstantiationDependent() ||
2689 E->containsUnexpandedParameterPack() ||
2690 CanonPVD->getType()->hasIntegerRepresentation())
2691 NewSteps.push_back(Step);
2692 else {
2693 Diag(Step->getExprLoc(), diag::err_omp_expected_int_param)
2694 << Step->getSourceRange();
2695 }
2696 continue;
2697 }
2698 NewStep = Step;
2699 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() &&
2700 !Step->isInstantiationDependent() &&
2701 !Step->containsUnexpandedParameterPack()) {
2702 NewStep = PerformOpenMPImplicitIntegerConversion(Step->getExprLoc(), Step)
2703 .get();
2704 if (NewStep)
2705 NewStep = VerifyIntegerConstantExpression(NewStep).get();
2706 }
2707 NewSteps.push_back(NewStep);
2708 }
2709 auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
2710 Context, BS, SL.get(), const_cast<Expr **>(Uniforms.data()),
2711 Uniforms.size(), const_cast<Expr **>(Aligneds.data()), Aligneds.size(),
2712 const_cast<Expr **>(NewAligns.data()), NewAligns.size(),
2713 const_cast<Expr **>(Linears.data()), Linears.size(),
2714 const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(),
2715 NewSteps.data(), NewSteps.size(), SR);
2716 ADecl->addAttr(NewAttr);
2717 return ConvertDeclToDeclGroup(ADecl);
2718}
2719
2720StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
2721 Stmt *AStmt,
2722 SourceLocation StartLoc,
2723 SourceLocation EndLoc) {
2724 if (!AStmt)
2725 return StmtError();
2726
2727 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
2728 // 1.2.2 OpenMP Language Terminology
2729 // Structured block - An executable statement with a single entry at the
2730 // top and a single exit at the bottom.
2731 // The point of exit cannot be a branch out of the structured block.
2732 // longjmp() and throw() must not violate the entry/exit criteria.
2733 CS->getCapturedDecl()->setNothrow();
2734
2735 getCurFunction()->setHasBranchProtectedScope();
2736
2737 return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
2738 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
2739}
2740
2741namespace {
2742/// \brief Helper class for checking canonical form of the OpenMP loops and
2743/// extracting iteration space of each loop in the loop nest, that will be used
2744/// for IR generation.
2745class OpenMPIterationSpaceChecker {
2746 /// \brief Reference to Sema.
2747 Sema &SemaRef;
2748 /// \brief A location for diagnostics (when there is no some better location).
2749 SourceLocation DefaultLoc;
2750 /// \brief A location for diagnostics (when increment is not compatible).
2751 SourceLocation ConditionLoc;
2752 /// \brief A source location for referring to loop init later.
2753 SourceRange InitSrcRange;
2754 /// \brief A source location for referring to condition later.
2755 SourceRange ConditionSrcRange;
2756 /// \brief A source location for referring to increment later.
2757 SourceRange IncrementSrcRange;
2758 /// \brief Loop variable.
2759 ValueDecl *LCDecl = nullptr;
2760 /// \brief Reference to loop variable.
2761 Expr *LCRef = nullptr;
2762 /// \brief Lower bound (initializer for the var).
2763 Expr *LB = nullptr;
4
Null pointer value stored to 'ISC.LB'
2764 /// \brief Upper bound.
2765 Expr *UB = nullptr;
2766 /// \brief Loop step (increment).
2767 Expr *Step = nullptr;
2768 /// \brief This flag is true when condition is one of:
2769 /// Var < UB
2770 /// Var <= UB
2771 /// UB > Var
2772 /// UB >= Var
2773 bool TestIsLessOp = false;
2774 /// \brief This flag is true when condition is strict ( < or > ).
2775 bool TestIsStrictOp = false;
2776 /// \brief This flag is true when step is subtracted on each iteration.
2777 bool SubtractStep = false;
2778
2779public:
2780 OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc)
2781 : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {}
2782 /// \brief Check init-expr for canonical loop form and save loop counter
2783 /// variable - #Var and its initialization value - #LB.
2784 bool CheckInit(Stmt *S, bool EmitDiags = true);
2785 /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags
2786 /// for less/greater and for strict/non-strict comparison.
2787 bool CheckCond(Expr *S);
2788 /// \brief Check incr-expr for canonical loop form and return true if it
2789 /// does not conform, otherwise save loop step (#Step).
2790 bool CheckInc(Expr *S);
2791 /// \brief Return the loop counter variable.
2792 ValueDecl *GetLoopDecl() const { return LCDecl; }
2793 /// \brief Return the reference expression to loop counter variable.
2794 Expr *GetLoopDeclRefExpr() const { return LCRef; }
2795 /// \brief Source range of the loop init.
2796 SourceRange GetInitSrcRange() const { return InitSrcRange; }
2797 /// \brief Source range of the loop condition.
2798 SourceRange GetConditionSrcRange() const { return ConditionSrcRange; }
2799 /// \brief Source range of the loop increment.
2800 SourceRange GetIncrementSrcRange() const { return IncrementSrcRange; }
2801 /// \brief True if the step should be subtracted.
2802 bool ShouldSubtractStep() const { return SubtractStep; }
2803 /// \brief Build the expression to calculate the number of iterations.
2804 Expr *
2805 BuildNumIterations(Scope *S, const bool LimitedType,
2806 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
2807 /// \brief Build the precondition expression for the loops.
2808 Expr *BuildPreCond(Scope *S, Expr *Cond,
2809 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const;
2810 /// \brief Build reference expression to the counter be used for codegen.
2811 DeclRefExpr *BuildCounterVar(llvm::MapVector<Expr *, DeclRefExpr *> &Captures,
2812 DSAStackTy &DSA) const;
2813 /// \brief Build reference expression to the private counter be used for
2814 /// codegen.
2815 Expr *BuildPrivateCounterVar() const;
2816 /// \brief Build initialization of the counter be used for codegen.
2817 Expr *BuildCounterInit() const;
2818 /// \brief Build step of the counter be used for codegen.
2819 Expr *BuildCounterStep() const;
2820 /// \brief Return true if any expression is dependent.
2821 bool Dependent() const;
2822
2823private:
2824 /// \brief Check the right-hand side of an assignment in the increment
2825 /// expression.
2826 bool CheckIncRHS(Expr *RHS);
2827 /// \brief Helper to set loop counter variable and its initializer.
2828 bool SetLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB);
2829 /// \brief Helper to set upper bound.
2830 bool SetUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR,
2831 SourceLocation SL);
2832 /// \brief Helper to set loop increment.
2833 bool SetStep(Expr *NewStep, bool Subtract);
2834};
2835
2836bool OpenMPIterationSpaceChecker::Dependent() const {
2837 if (!LCDecl) {
2838 assert(!LB && !UB && !Step)((!LB && !UB && !Step) ? static_cast<void>
(0) : __assert_fail ("!LB && !UB && !Step", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2838, __PRETTY_FUNCTION__))
;
2839 return false;
2840 }
2841 return LCDecl->getType()->isDependentType() ||
2842 (LB && LB->isValueDependent()) || (UB && UB->isValueDependent()) ||
2843 (Step && Step->isValueDependent());
2844}
2845
2846static Expr *getExprAsWritten(Expr *E) {
2847 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(E))
2848 E = ExprTemp->getSubExpr();
2849
2850 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
2851 E = MTE->GetTemporaryExpr();
2852
2853 while (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
2854 E = Binder->getSubExpr();
2855
2856 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
2857 E = ICE->getSubExprAsWritten();
2858 return E->IgnoreParens();
2859}
2860
2861bool OpenMPIterationSpaceChecker::SetLCDeclAndLB(ValueDecl *NewLCDecl,
2862 Expr *NewLCRefExpr,
2863 Expr *NewLB) {
2864 // State consistency checking to ensure correct usage.
2865 assert(LCDecl == nullptr && LB == nullptr && LCRef == nullptr &&((LCDecl == nullptr && LB == nullptr && LCRef
== nullptr && UB == nullptr && Step == nullptr
&& !TestIsLessOp && !TestIsStrictOp) ? static_cast
<void> (0) : __assert_fail ("LCDecl == nullptr && LB == nullptr && LCRef == nullptr && UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2866, __PRETTY_FUNCTION__))
2866 UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp)((LCDecl == nullptr && LB == nullptr && LCRef
== nullptr && UB == nullptr && Step == nullptr
&& !TestIsLessOp && !TestIsStrictOp) ? static_cast
<void> (0) : __assert_fail ("LCDecl == nullptr && LB == nullptr && LCRef == nullptr && UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2866, __PRETTY_FUNCTION__))
;
2867 if (!NewLCDecl || !NewLB)
2868 return true;
2869 LCDecl = getCanonicalDecl(NewLCDecl);
2870 LCRef = NewLCRefExpr;
2871 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(NewLB))
2872 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
2873 if ((Ctor->isCopyOrMoveConstructor() ||
2874 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
2875 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
2876 NewLB = CE->getArg(0)->IgnoreParenImpCasts();
2877 LB = NewLB;
2878 return false;
2879}
2880
2881bool OpenMPIterationSpaceChecker::SetUB(Expr *NewUB, bool LessOp, bool StrictOp,
2882 SourceRange SR, SourceLocation SL) {
2883 // State consistency checking to ensure correct usage.
2884 assert(LCDecl != nullptr && LB != nullptr && UB == nullptr &&((LCDecl != nullptr && LB != nullptr && UB ==
nullptr && Step == nullptr && !TestIsLessOp &&
!TestIsStrictOp) ? static_cast<void> (0) : __assert_fail
("LCDecl != nullptr && LB != nullptr && UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2885, __PRETTY_FUNCTION__))
2885 Step == nullptr && !TestIsLessOp && !TestIsStrictOp)((LCDecl != nullptr && LB != nullptr && UB ==
nullptr && Step == nullptr && !TestIsLessOp &&
!TestIsStrictOp) ? static_cast<void> (0) : __assert_fail
("LCDecl != nullptr && LB != nullptr && UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2885, __PRETTY_FUNCTION__))
;
2886 if (!NewUB)
2887 return true;
2888 UB = NewUB;
2889 TestIsLessOp = LessOp;
2890 TestIsStrictOp = StrictOp;
2891 ConditionSrcRange = SR;
2892 ConditionLoc = SL;
2893 return false;
2894}
2895
2896bool OpenMPIterationSpaceChecker::SetStep(Expr *NewStep, bool Subtract) {
2897 // State consistency checking to ensure correct usage.
2898 assert(LCDecl != nullptr && LB != nullptr && Step == nullptr)((LCDecl != nullptr && LB != nullptr && Step ==
nullptr) ? static_cast<void> (0) : __assert_fail ("LCDecl != nullptr && LB != nullptr && Step == nullptr"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 2898, __PRETTY_FUNCTION__))
;
2899 if (!NewStep)
2900 return true;
2901 if (!NewStep->isValueDependent()) {
2902 // Check that the step is integer expression.
2903 SourceLocation StepLoc = NewStep->getLocStart();
2904 ExprResult Val =
2905 SemaRef.PerformOpenMPImplicitIntegerConversion(StepLoc, NewStep);
2906 if (Val.isInvalid())
2907 return true;
2908 NewStep = Val.get();
2909
2910 // OpenMP [2.6, Canonical Loop Form, Restrictions]
2911 // If test-expr is of form var relational-op b and relational-op is < or
2912 // <= then incr-expr must cause var to increase on each iteration of the
2913 // loop. If test-expr is of form var relational-op b and relational-op is
2914 // > or >= then incr-expr must cause var to decrease on each iteration of
2915 // the loop.
2916 // If test-expr is of form b relational-op var and relational-op is < or
2917 // <= then incr-expr must cause var to decrease on each iteration of the
2918 // loop. If test-expr is of form b relational-op var and relational-op is
2919 // > or >= then incr-expr must cause var to increase on each iteration of
2920 // the loop.
2921 llvm::APSInt Result;
2922 bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context);
2923 bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation();
2924 bool IsConstNeg =
2925 IsConstant && Result.isSigned() && (Subtract != Result.isNegative());
2926 bool IsConstPos =
2927 IsConstant && Result.isSigned() && (Subtract == Result.isNegative());
2928 bool IsConstZero = IsConstant && !Result.getBoolValue();
2929 if (UB && (IsConstZero ||
2930 (TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract))
2931 : (IsConstPos || (IsUnsigned && !Subtract))))) {
2932 SemaRef.Diag(NewStep->getExprLoc(),
2933 diag::err_omp_loop_incr_not_compatible)
2934 << LCDecl << TestIsLessOp << NewStep->getSourceRange();
2935 SemaRef.Diag(ConditionLoc,
2936 diag::note_omp_loop_cond_requres_compatible_incr)
2937 << TestIsLessOp << ConditionSrcRange;
2938 return true;
2939 }
2940 if (TestIsLessOp == Subtract) {
2941 NewStep =
2942 SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus, NewStep)
2943 .get();
2944 Subtract = !Subtract;
2945 }
2946 }
2947
2948 Step = NewStep;
2949 SubtractStep = Subtract;
2950 return false;
2951}
2952
2953bool OpenMPIterationSpaceChecker::CheckInit(Stmt *S, bool EmitDiags) {
2954 // Check init-expr for canonical loop form and save loop counter
2955 // variable - #Var and its initialization value - #LB.
2956 // OpenMP [2.6] Canonical loop form. init-expr may be one of the following:
2957 // var = lb
2958 // integer-type var = lb
2959 // random-access-iterator-type var = lb
2960 // pointer-type var = lb
2961 //
2962 if (!S) {
2963 if (EmitDiags) {
2964 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_init);
2965 }
2966 return true;
2967 }
2968 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
2969 if (!ExprTemp->cleanupsHaveSideEffects())
2970 S = ExprTemp->getSubExpr();
2971
2972 InitSrcRange = S->getSourceRange();
2973 if (Expr *E = dyn_cast<Expr>(S))
2974 S = E->IgnoreParens();
2975 if (auto *BO = dyn_cast<BinaryOperator>(S)) {
2976 if (BO->getOpcode() == BO_Assign) {
2977 auto *LHS = BO->getLHS()->IgnoreParens();
2978 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
2979 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
2980 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
2981 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
2982 return SetLCDeclAndLB(DRE->getDecl(), DRE, BO->getRHS());
2983 }
2984 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
2985 if (ME->isArrow() &&
2986 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
2987 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
2988 }
2989 }
2990 } else if (auto *DS = dyn_cast<DeclStmt>(S)) {
2991 if (DS->isSingleDecl()) {
2992 if (auto *Var = dyn_cast_or_null<VarDecl>(DS->getSingleDecl())) {
2993 if (Var->hasInit() && !Var->getType()->isReferenceType()) {
2994 // Accept non-canonical init form here but emit ext. warning.
2995 if (Var->getInitStyle() != VarDecl::CInit && EmitDiags)
2996 SemaRef.Diag(S->getLocStart(),
2997 diag::ext_omp_loop_not_canonical_init)
2998 << S->getSourceRange();
2999 return SetLCDeclAndLB(Var, nullptr, Var->getInit());
3000 }
3001 }
3002 }
3003 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3004 if (CE->getOperator() == OO_Equal) {
3005 auto *LHS = CE->getArg(0);
3006 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
3007 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl()))
3008 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3009 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3010 return SetLCDeclAndLB(DRE->getDecl(), DRE, CE->getArg(1));
3011 }
3012 if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
3013 if (ME->isArrow() &&
3014 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3015 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS());
3016 }
3017 }
3018 }
3019
3020 if (Dependent() || SemaRef.CurContext->isDependentContext())
3021 return false;
3022 if (EmitDiags) {
3023 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_init)
3024 << S->getSourceRange();
3025 }
3026 return true;
3027}
3028
3029/// \brief Ignore parenthesizes, implicit casts, copy constructor and return the
3030/// variable (which may be the loop variable) if possible.
3031static const ValueDecl *GetInitLCDecl(Expr *E) {
3032 if (!E)
3033 return nullptr;
3034 E = getExprAsWritten(E);
3035 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(E))
3036 if (const CXXConstructorDecl *Ctor = CE->getConstructor())
3037 if ((Ctor->isCopyOrMoveConstructor() ||
3038 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) &&
3039 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr)
3040 E = CE->getArg(0)->IgnoreParenImpCasts();
3041 if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
3042 if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
3043 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
3044 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
3045 return getCanonicalDecl(ME->getMemberDecl());
3046 return getCanonicalDecl(VD);
3047 }
3048 }
3049 if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
3050 if (ME->isArrow() && isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))
3051 return getCanonicalDecl(ME->getMemberDecl());
3052 return nullptr;
3053}
3054
3055bool OpenMPIterationSpaceChecker::CheckCond(Expr *S) {
3056 // Check test-expr for canonical form, save upper-bound UB, flags for
3057 // less/greater and for strict/non-strict comparison.
3058 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
3059 // var relational-op b
3060 // b relational-op var
3061 //
3062 if (!S) {
3063 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_cond) << LCDecl;
3064 return true;
3065 }
3066 S = getExprAsWritten(S);
3067 SourceLocation CondLoc = S->getLocStart();
3068 if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3069 if (BO->isRelationalOp()) {
3070 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3071 return SetUB(BO->getRHS(),
3072 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_LE),
3073 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
3074 BO->getSourceRange(), BO->getOperatorLoc());
3075 if (GetInitLCDecl(BO->getRHS()) == LCDecl)
3076 return SetUB(BO->getLHS(),
3077 (BO->getOpcode() == BO_GT || BO->getOpcode() == BO_GE),
3078 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT),
3079 BO->getSourceRange(), BO->getOperatorLoc());
3080 }
3081 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3082 if (CE->getNumArgs() == 2) {
3083 auto Op = CE->getOperator();
3084 switch (Op) {
3085 case OO_Greater:
3086 case OO_GreaterEqual:
3087 case OO_Less:
3088 case OO_LessEqual:
3089 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3090 return SetUB(CE->getArg(1), Op == OO_Less || Op == OO_LessEqual,
3091 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
3092 CE->getOperatorLoc());
3093 if (GetInitLCDecl(CE->getArg(1)) == LCDecl)
3094 return SetUB(CE->getArg(0), Op == OO_Greater || Op == OO_GreaterEqual,
3095 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(),
3096 CE->getOperatorLoc());
3097 break;
3098 default:
3099 break;
3100 }
3101 }
3102 }
3103 if (Dependent() || SemaRef.CurContext->isDependentContext())
3104 return false;
3105 SemaRef.Diag(CondLoc, diag::err_omp_loop_not_canonical_cond)
3106 << S->getSourceRange() << LCDecl;
3107 return true;
3108}
3109
3110bool OpenMPIterationSpaceChecker::CheckIncRHS(Expr *RHS) {
3111 // RHS of canonical loop form increment can be:
3112 // var + incr
3113 // incr + var
3114 // var - incr
3115 //
3116 RHS = RHS->IgnoreParenImpCasts();
3117 if (auto *BO = dyn_cast<BinaryOperator>(RHS)) {
3118 if (BO->isAdditiveOp()) {
3119 bool IsAdd = BO->getOpcode() == BO_Add;
3120 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3121 return SetStep(BO->getRHS(), !IsAdd);
3122 if (IsAdd && GetInitLCDecl(BO->getRHS()) == LCDecl)
3123 return SetStep(BO->getLHS(), false);
3124 }
3125 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(RHS)) {
3126 bool IsAdd = CE->getOperator() == OO_Plus;
3127 if ((IsAdd || CE->getOperator() == OO_Minus) && CE->getNumArgs() == 2) {
3128 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3129 return SetStep(CE->getArg(1), !IsAdd);
3130 if (IsAdd && GetInitLCDecl(CE->getArg(1)) == LCDecl)
3131 return SetStep(CE->getArg(0), false);
3132 }
3133 }
3134 if (Dependent() || SemaRef.CurContext->isDependentContext())
3135 return false;
3136 SemaRef.Diag(RHS->getLocStart(), diag::err_omp_loop_not_canonical_incr)
3137 << RHS->getSourceRange() << LCDecl;
3138 return true;
3139}
3140
3141bool OpenMPIterationSpaceChecker::CheckInc(Expr *S) {
3142 // Check incr-expr for canonical loop form and return true if it
3143 // does not conform.
3144 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following:
3145 // ++var
3146 // var++
3147 // --var
3148 // var--
3149 // var += incr
3150 // var -= incr
3151 // var = var + incr
3152 // var = incr + var
3153 // var = var - incr
3154 //
3155 if (!S) {
3156 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_incr) << LCDecl;
3157 return true;
3158 }
3159 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S))
3160 if (!ExprTemp->cleanupsHaveSideEffects())
3161 S = ExprTemp->getSubExpr();
3162
3163 IncrementSrcRange = S->getSourceRange();
3164 S = S->IgnoreParens();
3165 if (auto *UO = dyn_cast<UnaryOperator>(S)) {
3166 if (UO->isIncrementDecrementOp() &&
3167 GetInitLCDecl(UO->getSubExpr()) == LCDecl)
3168 return SetStep(SemaRef
3169 .ActOnIntegerConstant(UO->getLocStart(),
3170 (UO->isDecrementOp() ? -1 : 1))
3171 .get(),
3172 false);
3173 } else if (auto *BO = dyn_cast<BinaryOperator>(S)) {
3174 switch (BO->getOpcode()) {
3175 case BO_AddAssign:
3176 case BO_SubAssign:
3177 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3178 return SetStep(BO->getRHS(), BO->getOpcode() == BO_SubAssign);
3179 break;
3180 case BO_Assign:
3181 if (GetInitLCDecl(BO->getLHS()) == LCDecl)
3182 return CheckIncRHS(BO->getRHS());
3183 break;
3184 default:
3185 break;
3186 }
3187 } else if (auto *CE = dyn_cast<CXXOperatorCallExpr>(S)) {
3188 switch (CE->getOperator()) {
3189 case OO_PlusPlus:
3190 case OO_MinusMinus:
3191 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3192 return SetStep(SemaRef
3193 .ActOnIntegerConstant(
3194 CE->getLocStart(),
3195 ((CE->getOperator() == OO_MinusMinus) ? -1 : 1))
3196 .get(),
3197 false);
3198 break;
3199 case OO_PlusEqual:
3200 case OO_MinusEqual:
3201 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3202 return SetStep(CE->getArg(1), CE->getOperator() == OO_MinusEqual);
3203 break;
3204 case OO_Equal:
3205 if (GetInitLCDecl(CE->getArg(0)) == LCDecl)
3206 return CheckIncRHS(CE->getArg(1));
3207 break;
3208 default:
3209 break;
3210 }
3211 }
3212 if (Dependent() || SemaRef.CurContext->isDependentContext())
3213 return false;
3214 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_incr)
3215 << S->getSourceRange() << LCDecl;
3216 return true;
3217}
3218
3219static ExprResult
3220tryBuildCapture(Sema &SemaRef, Expr *Capture,
3221 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3222 if (SemaRef.CurContext->isDependentContext())
13
Assuming the condition is false
14
Taking false branch
3223 return ExprResult(Capture);
3224 if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects))
15
Called C++ object pointer is null
3225 return SemaRef.PerformImplicitConversion(
3226 Capture->IgnoreImpCasts(), Capture->getType(), Sema::AA_Converting,
3227 /*AllowExplicit=*/true);
3228 auto I = Captures.find(Capture);
3229 if (I != Captures.end())
3230 return buildCapture(SemaRef, Capture, I->second);
3231 DeclRefExpr *Ref = nullptr;
3232 ExprResult Res = buildCapture(SemaRef, Capture, Ref);
3233 Captures[Capture] = Ref;
3234 return Res;
3235}
3236
3237/// \brief Build the expression to calculate the number of iterations.
3238Expr *OpenMPIterationSpaceChecker::BuildNumIterations(
3239 Scope *S, const bool LimitedType,
3240 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
3241 ExprResult Diff;
3242 auto VarType = LCDecl->getType().getNonReferenceType();
3243 if (VarType->isIntegerType() || VarType->isPointerType() ||
3244 SemaRef.getLangOpts().CPlusPlus) {
3245 // Upper - Lower
3246 auto *UBExpr = TestIsLessOp ? UB : LB;
3247 auto *LBExpr = TestIsLessOp ? LB : UB;
3248 Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get();
3249 Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get();
3250 if (!Upper || !Lower)
3251 return nullptr;
3252
3253 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Sub, Upper, Lower);
3254
3255 if (!Diff.isUsable() && VarType->getAsCXXRecordDecl()) {
3256 // BuildBinOp already emitted error, this one is to point user to upper
3257 // and lower bound, and to tell what is passed to 'operator-'.
3258 SemaRef.Diag(Upper->getLocStart(), diag::err_omp_loop_diff_cxx)
3259 << Upper->getSourceRange() << Lower->getSourceRange();
3260 return nullptr;
3261 }
3262 }
3263
3264 if (!Diff.isUsable())
3265 return nullptr;
3266
3267 // Upper - Lower [- 1]
3268 if (TestIsStrictOp)
3269 Diff = SemaRef.BuildBinOp(
3270 S, DefaultLoc, BO_Sub, Diff.get(),
3271 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3272 if (!Diff.isUsable())
3273 return nullptr;
3274
3275 // Upper - Lower [- 1] + Step
3276 auto NewStep = tryBuildCapture(SemaRef, Step, Captures);
3277 if (!NewStep.isUsable())
3278 return nullptr;
3279 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Add, Diff.get(), NewStep.get());
3280 if (!Diff.isUsable())
3281 return nullptr;
3282
3283 // Parentheses (for dumping/debugging purposes only).
3284 Diff = SemaRef.ActOnParenExpr(DefaultLoc, DefaultLoc, Diff.get());
3285 if (!Diff.isUsable())
3286 return nullptr;
3287
3288 // (Upper - Lower [- 1] + Step) / Step
3289 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Div, Diff.get(), NewStep.get());
3290 if (!Diff.isUsable())
3291 return nullptr;
3292
3293 // OpenMP runtime requires 32-bit or 64-bit loop variables.
3294 QualType Type = Diff.get()->getType();
3295 auto &C = SemaRef.Context;
3296 bool UseVarType = VarType->hasIntegerRepresentation() &&
3297 C.getTypeSize(Type) > C.getTypeSize(VarType);
3298 if (!Type->isIntegerType() || UseVarType) {
3299 unsigned NewSize =
3300 UseVarType ? C.getTypeSize(VarType) : C.getTypeSize(Type);
3301 bool IsSigned = UseVarType ? VarType->hasSignedIntegerRepresentation()
3302 : Type->hasSignedIntegerRepresentation();
3303 Type = C.getIntTypeForBitwidth(NewSize, IsSigned);
3304 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), Type)) {
3305 Diff = SemaRef.PerformImplicitConversion(
3306 Diff.get(), Type, Sema::AA_Converting, /*AllowExplicit=*/true);
3307 if (!Diff.isUsable())
3308 return nullptr;
3309 }
3310 }
3311 if (LimitedType) {
3312 unsigned NewSize = (C.getTypeSize(Type) > 32) ? 64 : 32;
3313 if (NewSize != C.getTypeSize(Type)) {
3314 if (NewSize < C.getTypeSize(Type)) {
3315 assert(NewSize == 64 && "incorrect loop var size")((NewSize == 64 && "incorrect loop var size") ? static_cast
<void> (0) : __assert_fail ("NewSize == 64 && \"incorrect loop var size\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 3315, __PRETTY_FUNCTION__))
;
3316 SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var)
3317 << InitSrcRange << ConditionSrcRange;
3318 }
3319 QualType NewType = C.getIntTypeForBitwidth(
3320 NewSize, Type->hasSignedIntegerRepresentation() ||
3321 C.getTypeSize(Type) < NewSize);
3322 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), NewType)) {
3323 Diff = SemaRef.PerformImplicitConversion(Diff.get(), NewType,
3324 Sema::AA_Converting, true);
3325 if (!Diff.isUsable())
3326 return nullptr;
3327 }
3328 }
3329 }
3330
3331 return Diff.get();
3332}
3333
3334Expr *OpenMPIterationSpaceChecker::BuildPreCond(
3335 Scope *S, Expr *Cond,
3336 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const {
3337 // Try to build LB <op> UB, where <op> is <, >, <=, or >=.
3338 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
3339 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
3340
3341 auto NewLB = tryBuildCapture(SemaRef, LB, Captures);
11
Passing null pointer value via 2nd parameter 'Capture'
12
Calling 'tryBuildCapture'
3342 auto NewUB = tryBuildCapture(SemaRef, UB, Captures);
3343 if (!NewLB.isUsable() || !NewUB.isUsable())
3344 return nullptr;
3345
3346 auto CondExpr = SemaRef.BuildBinOp(
3347 S, DefaultLoc, TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE)
3348 : (TestIsStrictOp ? BO_GT : BO_GE),
3349 NewLB.get(), NewUB.get());
3350 if (CondExpr.isUsable()) {
3351 if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(),
3352 SemaRef.Context.BoolTy))
3353 CondExpr = SemaRef.PerformImplicitConversion(
3354 CondExpr.get(), SemaRef.Context.BoolTy, /*Action=*/Sema::AA_Casting,
3355 /*AllowExplicit=*/true);
3356 }
3357 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
3358 // Otherwise use original loop conditon and evaluate it in runtime.
3359 return CondExpr.isUsable() ? CondExpr.get() : Cond;
3360}
3361
3362/// \brief Build reference expression to the counter be used for codegen.
3363DeclRefExpr *OpenMPIterationSpaceChecker::BuildCounterVar(
3364 llvm::MapVector<Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const {
3365 auto *VD = dyn_cast<VarDecl>(LCDecl);
3366 if (!VD) {
3367 VD = SemaRef.IsOpenMPCapturedDecl(LCDecl);
3368 auto *Ref = buildDeclRefExpr(
3369 SemaRef, VD, VD->getType().getNonReferenceType(), DefaultLoc);
3370 DSAStackTy::DSAVarData Data = DSA.getTopDSA(LCDecl, /*FromParent=*/false);
3371 // If the loop control decl is explicitly marked as private, do not mark it
3372 // as captured again.
3373 if (!isOpenMPPrivate(Data.CKind) || !Data.RefExpr)
3374 Captures.insert(std::make_pair(LCRef, Ref));
3375 return Ref;
3376 }
3377 return buildDeclRefExpr(SemaRef, VD, VD->getType().getNonReferenceType(),
3378 DefaultLoc);
3379}
3380
3381Expr *OpenMPIterationSpaceChecker::BuildPrivateCounterVar() const {
3382 if (LCDecl && !LCDecl->isInvalidDecl()) {
3383 auto Type = LCDecl->getType().getNonReferenceType();
3384 auto *PrivateVar =
3385 buildVarDecl(SemaRef, DefaultLoc, Type, LCDecl->getName(),
3386 LCDecl->hasAttrs() ? &LCDecl->getAttrs() : nullptr);
3387 if (PrivateVar->isInvalidDecl())
3388 return nullptr;
3389 return buildDeclRefExpr(SemaRef, PrivateVar, Type, DefaultLoc);
3390 }
3391 return nullptr;
3392}
3393
3394/// \brief Build initialization of the counter to be used for codegen.
3395Expr *OpenMPIterationSpaceChecker::BuildCounterInit() const { return LB; }
3396
3397/// \brief Build step of the counter be used for codegen.
3398Expr *OpenMPIterationSpaceChecker::BuildCounterStep() const { return Step; }
3399
3400/// \brief Iteration space of a single for loop.
3401struct LoopIterationSpace final {
3402 /// \brief Condition of the loop.
3403 Expr *PreCond = nullptr;
3404 /// \brief This expression calculates the number of iterations in the loop.
3405 /// It is always possible to calculate it before starting the loop.
3406 Expr *NumIterations = nullptr;
3407 /// \brief The loop counter variable.
3408 Expr *CounterVar = nullptr;
3409 /// \brief Private loop counter variable.
3410 Expr *PrivateCounterVar = nullptr;
3411 /// \brief This is initializer for the initial value of #CounterVar.
3412 Expr *CounterInit = nullptr;
3413 /// \brief This is step for the #CounterVar used to generate its update:
3414 /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration.
3415 Expr *CounterStep = nullptr;
3416 /// \brief Should step be subtracted?
3417 bool Subtract = false;
3418 /// \brief Source range of the loop init.
3419 SourceRange InitSrcRange;
3420 /// \brief Source range of the loop condition.
3421 SourceRange CondSrcRange;
3422 /// \brief Source range of the loop increment.
3423 SourceRange IncSrcRange;
3424};
3425
3426} // namespace
3427
3428void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) {
3429 assert(getLangOpts().OpenMP && "OpenMP is not active.")((getLangOpts().OpenMP && "OpenMP is not active.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().OpenMP && \"OpenMP is not active.\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 3429, __PRETTY_FUNCTION__))
;
3430 assert(Init && "Expected loop in canonical form.")((Init && "Expected loop in canonical form.") ? static_cast
<void> (0) : __assert_fail ("Init && \"Expected loop in canonical form.\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 3430, __PRETTY_FUNCTION__))
;
3431 unsigned AssociatedLoops = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getAssociatedLoops();
3432 if (AssociatedLoops > 0 &&
3433 isOpenMPLoopDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective())) {
3434 OpenMPIterationSpaceChecker ISC(*this, ForLoc);
3435 if (!ISC.CheckInit(Init, /*EmitDiags=*/false)) {
3436 if (auto *D = ISC.GetLoopDecl()) {
3437 auto *VD = dyn_cast<VarDecl>(D);
3438 if (!VD) {
3439 if (auto *Private = IsOpenMPCapturedDecl(D))
3440 VD = Private;
3441 else {
3442 auto *Ref = buildCapture(*this, D, ISC.GetLoopDeclRefExpr(),
3443 /*WithInit=*/false);
3444 VD = cast<VarDecl>(Ref->getDecl());
3445 }
3446 }
3447 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->addLoopControlVariable(D, VD);
3448 }
3449 }
3450 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setAssociatedLoops(AssociatedLoops - 1);
3451 }
3452}
3453
3454/// \brief Called on a for stmt to check and extract its iteration space
3455/// for further processing (such as collapsing).
3456static bool CheckOpenMPIterationSpace(
3457 OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA,
3458 unsigned CurrentNestedLoopCount, unsigned NestedLoopCount,
3459 Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr,
3460 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
3461 LoopIterationSpace &ResultIterSpace,
3462 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3463 // OpenMP [2.6, Canonical Loop Form]
3464 // for (init-expr; test-expr; incr-expr) structured-block
3465 auto *For = dyn_cast_or_null<ForStmt>(S);
3466 if (!For) {
1
Assuming 'For' is non-null
2
Taking false branch
3467 SemaRef.Diag(S->getLocStart(), diag::err_omp_not_for)
3468 << (CollapseLoopCountExpr != nullptr || OrderedLoopCountExpr != nullptr)
3469 << getOpenMPDirectiveName(DKind) << NestedLoopCount
3470 << (CurrentNestedLoopCount > 0) << CurrentNestedLoopCount;
3471 if (NestedLoopCount > 1) {
3472 if (CollapseLoopCountExpr && OrderedLoopCountExpr)
3473 SemaRef.Diag(DSA.getConstructLoc(),
3474 diag::note_omp_collapse_ordered_expr)
3475 << 2 << CollapseLoopCountExpr->getSourceRange()
3476 << OrderedLoopCountExpr->getSourceRange();
3477 else if (CollapseLoopCountExpr)
3478 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
3479 diag::note_omp_collapse_ordered_expr)
3480 << 0 << CollapseLoopCountExpr->getSourceRange();
3481 else
3482 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
3483 diag::note_omp_collapse_ordered_expr)
3484 << 1 << OrderedLoopCountExpr->getSourceRange();
3485 }
3486 return true;
3487 }
3488 assert(For->getBody())((For->getBody()) ? static_cast<void> (0) : __assert_fail
("For->getBody()", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 3488, __PRETTY_FUNCTION__))
;
3489
3490 OpenMPIterationSpaceChecker ISC(SemaRef, For->getForLoc());
3
Calling constructor for 'OpenMPIterationSpaceChecker'
5
Returning from constructor for 'OpenMPIterationSpaceChecker'
3491
3492 // Check init.
3493 auto Init = For->getInit();
3494 if (ISC.CheckInit(Init))
6
Taking false branch
3495 return true;
3496
3497 bool HasErrors = false;
3498
3499 // Check loop variable's type.
3500 if (auto *LCDecl = ISC.GetLoopDecl()) {
7
Taking false branch
3501 auto *LoopDeclRefExpr = ISC.GetLoopDeclRefExpr();
3502
3503 // OpenMP [2.6, Canonical Loop Form]
3504 // Var is one of the following:
3505 // A variable of signed or unsigned integer type.
3506 // For C++, a variable of a random access iterator type.
3507 // For C, a variable of a pointer type.
3508 auto VarType = LCDecl->getType().getNonReferenceType();
3509 if (!VarType->isDependentType() && !VarType->isIntegerType() &&
3510 !VarType->isPointerType() &&
3511 !(SemaRef.getLangOpts().CPlusPlus && VarType->isOverloadableType())) {
3512 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_variable_type)
3513 << SemaRef.getLangOpts().CPlusPlus;
3514 HasErrors = true;
3515 }
3516
3517 // OpenMP, 2.14.1.1 Data-sharing Attribute Rules for Variables Referenced in
3518 // a Construct
3519 // The loop iteration variable(s) in the associated for-loop(s) of a for or
3520 // parallel for construct is (are) private.
3521 // The loop iteration variable in the associated for-loop of a simd
3522 // construct with just one associated for-loop is linear with a
3523 // constant-linear-step that is the increment of the associated for-loop.
3524 // Exclude loop var from the list of variables with implicitly defined data
3525 // sharing attributes.
3526 VarsWithImplicitDSA.erase(LCDecl);
3527
3528 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced
3529 // in a Construct, C/C++].
3530 // The loop iteration variable in the associated for-loop of a simd
3531 // construct with just one associated for-loop may be listed in a linear
3532 // clause with a constant-linear-step that is the increment of the
3533 // associated for-loop.
3534 // The loop iteration variable(s) in the associated for-loop(s) of a for or
3535 // parallel for construct may be listed in a private or lastprivate clause.
3536 DSAStackTy::DSAVarData DVar = DSA.getTopDSA(LCDecl, false);
3537 // If LoopVarRefExpr is nullptr it means the corresponding loop variable is
3538 // declared in the loop and it is predetermined as a private.
3539 auto PredeterminedCKind =
3540 isOpenMPSimdDirective(DKind)
3541 ? ((NestedLoopCount == 1) ? OMPC_linear : OMPC_lastprivate)
3542 : OMPC_private;
3543 if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
3544 DVar.CKind != PredeterminedCKind) ||
3545 ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop ||
3546 isOpenMPDistributeDirective(DKind)) &&
3547 !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown &&
3548 DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) &&
3549 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) {
3550 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_var_dsa)
3551 << getOpenMPClauseName(DVar.CKind) << getOpenMPDirectiveName(DKind)
3552 << getOpenMPClauseName(PredeterminedCKind);
3553 if (DVar.RefExpr == nullptr)
3554 DVar.CKind = PredeterminedCKind;
3555 ReportOriginalDSA(SemaRef, &DSA, LCDecl, DVar, /*IsLoopIterVar=*/true);
3556 HasErrors = true;
3557 } else if (LoopDeclRefExpr != nullptr) {
3558 // Make the loop iteration variable private (for worksharing constructs),
3559 // linear (for simd directives with the only one associated loop) or
3560 // lastprivate (for simd directives with several collapsed or ordered
3561 // loops).
3562 if (DVar.CKind == OMPC_unknown)
3563 DVar = DSA.hasDSA(LCDecl, isOpenMPPrivate,
3564 [](OpenMPDirectiveKind) -> bool { return true; },
3565 /*FromParent=*/false);
3566 DSA.addDSA(LCDecl, LoopDeclRefExpr, PredeterminedCKind);
3567 }
3568
3569 assert(isOpenMPLoopDirective(DKind) && "DSA for non-loop vars")((isOpenMPLoopDirective(DKind) && "DSA for non-loop vars"
) ? static_cast<void> (0) : __assert_fail ("isOpenMPLoopDirective(DKind) && \"DSA for non-loop vars\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 3569, __PRETTY_FUNCTION__))
;
3570
3571 // Check test-expr.
3572 HasErrors |= ISC.CheckCond(For->getCond());
3573
3574 // Check incr-expr.
3575 HasErrors |= ISC.CheckInc(For->getInc());
3576 }
3577
3578 if (ISC.Dependent() || SemaRef.CurContext->isDependentContext() || HasErrors)
8
Assuming the condition is false
9
Taking false branch
3579 return HasErrors;
3580
3581 // Build the loop's iteration space representation.
3582 ResultIterSpace.PreCond =
3583 ISC.BuildPreCond(DSA.getCurScope(), For->getCond(), Captures);
10
Calling 'OpenMPIterationSpaceChecker::BuildPreCond'
3584 ResultIterSpace.NumIterations = ISC.BuildNumIterations(
3585 DSA.getCurScope(),
3586 (isOpenMPWorksharingDirective(DKind) ||
3587 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)),
3588 Captures);
3589 ResultIterSpace.CounterVar = ISC.BuildCounterVar(Captures, DSA);
3590 ResultIterSpace.PrivateCounterVar = ISC.BuildPrivateCounterVar();
3591 ResultIterSpace.CounterInit = ISC.BuildCounterInit();
3592 ResultIterSpace.CounterStep = ISC.BuildCounterStep();
3593 ResultIterSpace.InitSrcRange = ISC.GetInitSrcRange();
3594 ResultIterSpace.CondSrcRange = ISC.GetConditionSrcRange();
3595 ResultIterSpace.IncSrcRange = ISC.GetIncrementSrcRange();
3596 ResultIterSpace.Subtract = ISC.ShouldSubtractStep();
3597
3598 HasErrors |= (ResultIterSpace.PreCond == nullptr ||
3599 ResultIterSpace.NumIterations == nullptr ||
3600 ResultIterSpace.CounterVar == nullptr ||
3601 ResultIterSpace.PrivateCounterVar == nullptr ||
3602 ResultIterSpace.CounterInit == nullptr ||
3603 ResultIterSpace.CounterStep == nullptr);
3604
3605 return HasErrors;
3606}
3607
3608/// \brief Build 'VarRef = Start.
3609static ExprResult
3610BuildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef,
3611 ExprResult Start,
3612 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3613 // Build 'VarRef = Start.
3614 auto NewStart = tryBuildCapture(SemaRef, Start.get(), Captures);
3615 if (!NewStart.isUsable())
3616 return ExprError();
3617 if (!SemaRef.Context.hasSameType(NewStart.get()->getType(),
3618 VarRef.get()->getType())) {
3619 NewStart = SemaRef.PerformImplicitConversion(
3620 NewStart.get(), VarRef.get()->getType(), Sema::AA_Converting,
3621 /*AllowExplicit=*/true);
3622 if (!NewStart.isUsable())
3623 return ExprError();
3624 }
3625
3626 auto Init =
3627 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
3628 return Init;
3629}
3630
3631/// \brief Build 'VarRef = Start + Iter * Step'.
3632static ExprResult
3633BuildCounterUpdate(Sema &SemaRef, Scope *S, SourceLocation Loc,
3634 ExprResult VarRef, ExprResult Start, ExprResult Iter,
3635 ExprResult Step, bool Subtract,
3636 llvm::MapVector<Expr *, DeclRefExpr *> *Captures = nullptr) {
3637 // Add parentheses (for debugging purposes only).
3638 Iter = SemaRef.ActOnParenExpr(Loc, Loc, Iter.get());
3639 if (!VarRef.isUsable() || !Start.isUsable() || !Iter.isUsable() ||
3640 !Step.isUsable())
3641 return ExprError();
3642
3643 ExprResult NewStep = Step;
3644 if (Captures)
3645 NewStep = tryBuildCapture(SemaRef, Step.get(), *Captures);
3646 if (NewStep.isInvalid())
3647 return ExprError();
3648 ExprResult Update =
3649 SemaRef.BuildBinOp(S, Loc, BO_Mul, Iter.get(), NewStep.get());
3650 if (!Update.isUsable())
3651 return ExprError();
3652
3653 // Try to build 'VarRef = Start, VarRef (+|-)= Iter * Step' or
3654 // 'VarRef = Start (+|-) Iter * Step'.
3655 ExprResult NewStart = Start;
3656 if (Captures)
3657 NewStart = tryBuildCapture(SemaRef, Start.get(), *Captures);
3658 if (NewStart.isInvalid())
3659 return ExprError();
3660
3661 // First attempt: try to build 'VarRef = Start, VarRef += Iter * Step'.
3662 ExprResult SavedUpdate = Update;
3663 ExprResult UpdateVal;
3664 if (VarRef.get()->getType()->isOverloadableType() ||
3665 NewStart.get()->getType()->isOverloadableType() ||
3666 Update.get()->getType()->isOverloadableType()) {
3667 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics();
3668 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true);
3669 Update =
3670 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get());
3671 if (Update.isUsable()) {
3672 UpdateVal =
3673 SemaRef.BuildBinOp(S, Loc, Subtract ? BO_SubAssign : BO_AddAssign,
3674 VarRef.get(), SavedUpdate.get());
3675 if (UpdateVal.isUsable()) {
3676 Update = SemaRef.CreateBuiltinBinOp(Loc, BO_Comma, Update.get(),
3677 UpdateVal.get());
3678 }
3679 }
3680 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress);
3681 }
3682
3683 // Second attempt: try to build 'VarRef = Start (+|-) Iter * Step'.
3684 if (!Update.isUsable() || !UpdateVal.isUsable()) {
3685 Update = SemaRef.BuildBinOp(S, Loc, Subtract ? BO_Sub : BO_Add,
3686 NewStart.get(), SavedUpdate.get());
3687 if (!Update.isUsable())
3688 return ExprError();
3689
3690 if (!SemaRef.Context.hasSameType(Update.get()->getType(),
3691 VarRef.get()->getType())) {
3692 Update = SemaRef.PerformImplicitConversion(
3693 Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true);
3694 if (!Update.isUsable())
3695 return ExprError();
3696 }
3697
3698 Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get());
3699 }
3700 return Update;
3701}
3702
3703/// \brief Convert integer expression \a E to make it have at least \a Bits
3704/// bits.
3705static ExprResult WidenIterationCount(unsigned Bits, Expr *E, Sema &SemaRef) {
3706 if (E == nullptr)
3707 return ExprError();
3708 auto &C = SemaRef.Context;
3709 QualType OldType = E->getType();
3710 unsigned HasBits = C.getTypeSize(OldType);
3711 if (HasBits >= Bits)
3712 return ExprResult(E);
3713 // OK to convert to signed, because new type has more bits than old.
3714 QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
3715 return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
3716 true);
3717}
3718
3719/// \brief Check if the given expression \a E is a constant integer that fits
3720/// into \a Bits bits.
3721static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
3722 if (E == nullptr)
3723 return false;
3724 llvm::APSInt Result;
3725 if (E->isIntegerConstantExpr(Result, SemaRef.Context))
3726 return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits);
3727 return false;
3728}
3729
3730/// Build preinits statement for the given declarations.
3731static Stmt *buildPreInits(ASTContext &Context,
3732 SmallVectorImpl<Decl *> &PreInits) {
3733 if (!PreInits.empty()) {
3734 return new (Context) DeclStmt(
3735 DeclGroupRef::Create(Context, PreInits.begin(), PreInits.size()),
3736 SourceLocation(), SourceLocation());
3737 }
3738 return nullptr;
3739}
3740
3741/// Build preinits statement for the given declarations.
3742static Stmt *buildPreInits(ASTContext &Context,
3743 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) {
3744 if (!Captures.empty()) {
3745 SmallVector<Decl *, 16> PreInits;
3746 for (auto &Pair : Captures)
3747 PreInits.push_back(Pair.second->getDecl());
3748 return buildPreInits(Context, PreInits);
3749 }
3750 return nullptr;
3751}
3752
3753/// Build postupdate expression for the given list of postupdates expressions.
3754static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) {
3755 Expr *PostUpdate = nullptr;
3756 if (!PostUpdates.empty()) {
3757 for (auto *E : PostUpdates) {
3758 Expr *ConvE = S.BuildCStyleCastExpr(
3759 E->getExprLoc(),
3760 S.Context.getTrivialTypeSourceInfo(S.Context.VoidTy),
3761 E->getExprLoc(), E)
3762 .get();
3763 PostUpdate = PostUpdate
3764 ? S.CreateBuiltinBinOp(ConvE->getExprLoc(), BO_Comma,
3765 PostUpdate, ConvE)
3766 .get()
3767 : ConvE;
3768 }
3769 }
3770 return PostUpdate;
3771}
3772
3773/// \brief Called on a for stmt to check itself and nested loops (if any).
3774/// \return Returns 0 if one of the collapsed stmts is not canonical for loop,
3775/// number of collapsed loops otherwise.
3776static unsigned
3777CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
3778 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
3779 DSAStackTy &DSA,
3780 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA,
3781 OMPLoopDirective::HelperExprs &Built) {
3782 unsigned NestedLoopCount = 1;
3783 if (CollapseLoopCountExpr) {
3784 // Found 'collapse' clause - calculate collapse number.
3785 llvm::APSInt Result;
3786 if (CollapseLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext()))
3787 NestedLoopCount = Result.getLimitedValue();
3788 }
3789 if (OrderedLoopCountExpr) {
3790 // Found 'ordered' clause - calculate collapse number.
3791 llvm::APSInt Result;
3792 if (OrderedLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) {
3793 if (Result.getLimitedValue() < NestedLoopCount) {
3794 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
3795 diag::err_omp_wrong_ordered_loop_count)
3796 << OrderedLoopCountExpr->getSourceRange();
3797 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(),
3798 diag::note_collapse_loop_count)
3799 << CollapseLoopCountExpr->getSourceRange();
3800 }
3801 NestedLoopCount = Result.getLimitedValue();
3802 }
3803 }
3804 // This is helper routine for loop directives (e.g., 'for', 'simd',
3805 // 'for simd', etc.).
3806 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
3807 SmallVector<LoopIterationSpace, 4> IterSpaces;
3808 IterSpaces.resize(NestedLoopCount);
3809 Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true);
3810 for (unsigned Cnt = 0; Cnt < NestedLoopCount; ++Cnt) {
3811 if (CheckOpenMPIterationSpace(DKind, CurStmt, SemaRef, DSA, Cnt,
3812 NestedLoopCount, CollapseLoopCountExpr,
3813 OrderedLoopCountExpr, VarsWithImplicitDSA,
3814 IterSpaces[Cnt], Captures))
3815 return 0;
3816 // Move on to the next nested for loop, or to the loop body.
3817 // OpenMP [2.8.1, simd construct, Restrictions]
3818 // All loops associated with the construct must be perfectly nested; that
3819 // is, there must be no intervening code nor any OpenMP directive between
3820 // any two loops.
3821 CurStmt = cast<ForStmt>(CurStmt)->getBody()->IgnoreContainers();
3822 }
3823
3824 Built.clear(/* size */ NestedLoopCount);
3825
3826 if (SemaRef.CurContext->isDependentContext())
3827 return NestedLoopCount;
3828
3829 // An example of what is generated for the following code:
3830 //
3831 // #pragma omp simd collapse(2) ordered(2)
3832 // for (i = 0; i < NI; ++i)
3833 // for (k = 0; k < NK; ++k)
3834 // for (j = J0; j < NJ; j+=2) {
3835 // <loop body>
3836 // }
3837 //
3838 // We generate the code below.
3839 // Note: the loop body may be outlined in CodeGen.
3840 // Note: some counters may be C++ classes, operator- is used to find number of
3841 // iterations and operator+= to calculate counter value.
3842 // Note: decltype(NumIterations) must be integer type (in 'omp for', only i32
3843 // or i64 is currently supported).
3844 //
3845 // #define NumIterations (NI * ((NJ - J0 - 1 + 2) / 2))
3846 // for (int[32|64]_t IV = 0; IV < NumIterations; ++IV ) {
3847 // .local.i = IV / ((NJ - J0 - 1 + 2) / 2);
3848 // .local.j = J0 + (IV % ((NJ - J0 - 1 + 2) / 2)) * 2;
3849 // // similar updates for vars in clauses (e.g. 'linear')
3850 // <loop body (using local i and j)>
3851 // }
3852 // i = NI; // assign final values of counters
3853 // j = NJ;
3854 //
3855
3856 // Last iteration number is (I1 * I2 * ... In) - 1, where I1, I2 ... In are
3857 // the iteration counts of the collapsed for loops.
3858 // Precondition tests if there is at least one iteration (all conditions are
3859 // true).
3860 auto PreCond = ExprResult(IterSpaces[0].PreCond);
3861 auto N0 = IterSpaces[0].NumIterations;
3862 ExprResult LastIteration32 = WidenIterationCount(
3863 32 /* Bits */, SemaRef
3864 .PerformImplicitConversion(
3865 N0->IgnoreImpCasts(), N0->getType(),
3866 Sema::AA_Converting, /*AllowExplicit=*/true)
3867 .get(),
3868 SemaRef);
3869 ExprResult LastIteration64 = WidenIterationCount(
3870 64 /* Bits */, SemaRef
3871 .PerformImplicitConversion(
3872 N0->IgnoreImpCasts(), N0->getType(),
3873 Sema::AA_Converting, /*AllowExplicit=*/true)
3874 .get(),
3875 SemaRef);
3876
3877 if (!LastIteration32.isUsable() || !LastIteration64.isUsable())
3878 return NestedLoopCount;
3879
3880 auto &C = SemaRef.Context;
3881 bool AllCountsNeedLessThan32Bits = C.getTypeSize(N0->getType()) < 32;
3882
3883 Scope *CurScope = DSA.getCurScope();
3884 for (unsigned Cnt = 1; Cnt < NestedLoopCount; ++Cnt) {
3885 if (PreCond.isUsable()) {
3886 PreCond =
3887 SemaRef.BuildBinOp(CurScope, PreCond.get()->getExprLoc(), BO_LAnd,
3888 PreCond.get(), IterSpaces[Cnt].PreCond);
3889 }
3890 auto N = IterSpaces[Cnt].NumIterations;
3891 SourceLocation Loc = N->getExprLoc();
3892 AllCountsNeedLessThan32Bits &= C.getTypeSize(N->getType()) < 32;
3893 if (LastIteration32.isUsable())
3894 LastIteration32 = SemaRef.BuildBinOp(
3895 CurScope, Loc, BO_Mul, LastIteration32.get(),
3896 SemaRef
3897 .PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
3898 Sema::AA_Converting,
3899 /*AllowExplicit=*/true)
3900 .get());
3901 if (LastIteration64.isUsable())
3902 LastIteration64 = SemaRef.BuildBinOp(
3903 CurScope, Loc, BO_Mul, LastIteration64.get(),
3904 SemaRef
3905 .PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(),
3906 Sema::AA_Converting,
3907 /*AllowExplicit=*/true)
3908 .get());
3909 }
3910
3911 // Choose either the 32-bit or 64-bit version.
3912 ExprResult LastIteration = LastIteration64;
3913 if (LastIteration32.isUsable() &&
3914 C.getTypeSize(LastIteration32.get()->getType()) == 32 &&
3915 (AllCountsNeedLessThan32Bits || NestedLoopCount == 1 ||
3916 FitsInto(
3917 32 /* Bits */,
3918 LastIteration32.get()->getType()->hasSignedIntegerRepresentation(),
3919 LastIteration64.get(), SemaRef)))
3920 LastIteration = LastIteration32;
3921 QualType VType = LastIteration.get()->getType();
3922 QualType RealVType = VType;
3923 QualType StrideVType = VType;
3924 if (isOpenMPTaskLoopDirective(DKind)) {
3925 VType =
3926 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0);
3927 StrideVType =
3928 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1);
3929 }
3930
3931 if (!LastIteration.isUsable())
3932 return 0;
3933
3934 // Save the number of iterations.
3935 ExprResult NumIterations = LastIteration;
3936 {
3937 LastIteration = SemaRef.BuildBinOp(
3938 CurScope, LastIteration.get()->getExprLoc(), BO_Sub,
3939 LastIteration.get(),
3940 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3941 if (!LastIteration.isUsable())
3942 return 0;
3943 }
3944
3945 // Calculate the last iteration number beforehand instead of doing this on
3946 // each iteration. Do not do this if the number of iterations may be kfold-ed.
3947 llvm::APSInt Result;
3948 bool IsConstant =
3949 LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context);
3950 ExprResult CalcLastIteration;
3951 if (!IsConstant) {
3952 ExprResult SaveRef =
3953 tryBuildCapture(SemaRef, LastIteration.get(), Captures);
3954 LastIteration = SaveRef;
3955
3956 // Prepare SaveRef + 1.
3957 NumIterations = SemaRef.BuildBinOp(
3958 CurScope, SaveRef.get()->getExprLoc(), BO_Add, SaveRef.get(),
3959 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get());
3960 if (!NumIterations.isUsable())
3961 return 0;
3962 }
3963
3964 SourceLocation InitLoc = IterSpaces[0].InitSrcRange.getBegin();
3965
3966 // Build variables passed into runtime, necessary for worksharing directives.
3967 ExprResult LB, UB, IL, ST, EUB, PrevLB, PrevUB;
3968 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
3969 isOpenMPDistributeDirective(DKind)) {
3970 // Lower bound variable, initialized with zero.
3971 VarDecl *LBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.lb");
3972 LB = buildDeclRefExpr(SemaRef, LBDecl, VType, InitLoc);
3973 SemaRef.AddInitializerToDecl(
3974 LBDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
3975 /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
3976
3977 // Upper bound variable, initialized with last iteration number.
3978 VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
3979 UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
3980 SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
3981 /*DirectInit*/ false,
3982 /*TypeMayContainAuto*/ false);
3983
3984 // A 32-bit variable-flag where runtime returns 1 for the last iteration.
3985 // This will be used to implement clause 'lastprivate'.
3986 QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
3987 VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
3988 IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
3989 SemaRef.AddInitializerToDecl(
3990 ILDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
3991 /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
3992
3993 // Stride variable returned by runtime (we initialize it to 1 by default).
3994 VarDecl *STDecl =
3995 buildVarDecl(SemaRef, InitLoc, StrideVType, ".omp.stride");
3996 ST = buildDeclRefExpr(SemaRef, STDecl, StrideVType, InitLoc);
3997 SemaRef.AddInitializerToDecl(
3998 STDecl, SemaRef.ActOnIntegerConstant(InitLoc, 1).get(),
3999 /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
4000
4001 // Build expression: UB = min(UB, LastIteration)
4002 // It is necessary for CodeGen of directives with static scheduling.
4003 ExprResult IsUBGreater = SemaRef.BuildBinOp(CurScope, InitLoc, BO_GT,
4004 UB.get(), LastIteration.get());
4005 ExprResult CondOp = SemaRef.ActOnConditionalOp(
4006 InitLoc, InitLoc, IsUBGreater.get(), LastIteration.get(), UB.get());
4007 EUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, UB.get(),
4008 CondOp.get());
4009 EUB = SemaRef.ActOnFinishFullExpr(EUB.get());
4010
4011 // If we have a combined directive that combines 'distribute', 'for' or
4012 // 'simd' we need to be able to access the bounds of the schedule of the
4013 // enclosing region. E.g. in 'distribute parallel for' the bounds obtained
4014 // by scheduling 'distribute' have to be passed to the schedule of 'for'.
4015 if (isOpenMPLoopBoundSharingDirective(DKind)) {
4016 auto *CD = cast<CapturedStmt>(AStmt)->getCapturedDecl();
4017
4018 // We expect to have at least 2 more parameters than the 'parallel'
4019 // directive does - the lower and upper bounds of the previous schedule.
4020 assert(CD->getNumParams() >= 4 &&((CD->getNumParams() >= 4 && "Unexpected number of parameters in loop combined directive"
) ? static_cast<void> (0) : __assert_fail ("CD->getNumParams() >= 4 && \"Unexpected number of parameters in loop combined directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4021, __PRETTY_FUNCTION__))
4021 "Unexpected number of parameters in loop combined directive")((CD->getNumParams() >= 4 && "Unexpected number of parameters in loop combined directive"
) ? static_cast<void> (0) : __assert_fail ("CD->getNumParams() >= 4 && \"Unexpected number of parameters in loop combined directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4021, __PRETTY_FUNCTION__))
;
4022
4023 // Set the proper type for the bounds given what we learned from the
4024 // enclosed loops.
4025 auto *PrevLBDecl = CD->getParam(/*PrevLB=*/2);
4026 auto *PrevUBDecl = CD->getParam(/*PrevUB=*/3);
4027
4028 // Previous lower and upper bounds are obtained from the region
4029 // parameters.
4030 PrevLB =
4031 buildDeclRefExpr(SemaRef, PrevLBDecl, PrevLBDecl->getType(), InitLoc);
4032 PrevUB =
4033 buildDeclRefExpr(SemaRef, PrevUBDecl, PrevUBDecl->getType(), InitLoc);
4034 }
4035 }
4036
4037 // Build the iteration variable and its initialization before loop.
4038 ExprResult IV;
4039 ExprResult Init;
4040 {
4041 VarDecl *IVDecl = buildVarDecl(SemaRef, InitLoc, RealVType, ".omp.iv");
4042 IV = buildDeclRefExpr(SemaRef, IVDecl, RealVType, InitLoc);
4043 Expr *RHS =
4044 (isOpenMPWorksharingDirective(DKind) ||
4045 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
4046 ? LB.get()
4047 : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
4048 Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS);
4049 Init = SemaRef.ActOnFinishFullExpr(Init.get());
4050 }
4051
4052 // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops.
4053 SourceLocation CondLoc;
4054 ExprResult Cond =
4055 (isOpenMPWorksharingDirective(DKind) ||
4056 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
4057 ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get())
4058 : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(),
4059 NumIterations.get());
4060
4061 // Loop increment (IV = IV + 1)
4062 SourceLocation IncLoc;
4063 ExprResult Inc =
4064 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, IV.get(),
4065 SemaRef.ActOnIntegerConstant(IncLoc, 1).get());
4066 if (!Inc.isUsable())
4067 return 0;
4068 Inc = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, IV.get(), Inc.get());
4069 Inc = SemaRef.ActOnFinishFullExpr(Inc.get());
4070 if (!Inc.isUsable())
4071 return 0;
4072
4073 // Increments for worksharing loops (LB = LB + ST; UB = UB + ST).
4074 // Used for directives with static scheduling.
4075 ExprResult NextLB, NextUB;
4076 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) ||
4077 isOpenMPDistributeDirective(DKind)) {
4078 // LB + ST
4079 NextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, LB.get(), ST.get());
4080 if (!NextLB.isUsable())
4081 return 0;
4082 // LB = LB + ST
4083 NextLB =
4084 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, LB.get(), NextLB.get());
4085 NextLB = SemaRef.ActOnFinishFullExpr(NextLB.get());
4086 if (!NextLB.isUsable())
4087 return 0;
4088 // UB + ST
4089 NextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, UB.get(), ST.get());
4090 if (!NextUB.isUsable())
4091 return 0;
4092 // UB = UB + ST
4093 NextUB =
4094 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, UB.get(), NextUB.get());
4095 NextUB = SemaRef.ActOnFinishFullExpr(NextUB.get());
4096 if (!NextUB.isUsable())
4097 return 0;
4098 }
4099
4100 // Build updates and final values of the loop counters.
4101 bool HasErrors = false;
4102 Built.Counters.resize(NestedLoopCount);
4103 Built.Inits.resize(NestedLoopCount);
4104 Built.Updates.resize(NestedLoopCount);
4105 Built.Finals.resize(NestedLoopCount);
4106 SmallVector<Expr *, 4> LoopMultipliers;
4107 {
4108 ExprResult Div;
4109 // Go from inner nested loop to outer.
4110 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
4111 LoopIterationSpace &IS = IterSpaces[Cnt];
4112 SourceLocation UpdLoc = IS.IncSrcRange.getBegin();
4113 // Build: Iter = (IV / Div) % IS.NumIters
4114 // where Div is product of previous iterations' IS.NumIters.
4115 ExprResult Iter;
4116 if (Div.isUsable()) {
4117 Iter =
4118 SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Div, IV.get(), Div.get());
4119 } else {
4120 Iter = IV;
4121 assert((Cnt == (int)NestedLoopCount - 1) &&(((Cnt == (int)NestedLoopCount - 1) && "unusable div expected on first iteration only"
) ? static_cast<void> (0) : __assert_fail ("(Cnt == (int)NestedLoopCount - 1) && \"unusable div expected on first iteration only\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4122, __PRETTY_FUNCTION__))
4122 "unusable div expected on first iteration only")(((Cnt == (int)NestedLoopCount - 1) && "unusable div expected on first iteration only"
) ? static_cast<void> (0) : __assert_fail ("(Cnt == (int)NestedLoopCount - 1) && \"unusable div expected on first iteration only\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4122, __PRETTY_FUNCTION__))
;
4123 }
4124
4125 if (Cnt != 0 && Iter.isUsable())
4126 Iter = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Rem, Iter.get(),
4127 IS.NumIterations);
4128 if (!Iter.isUsable()) {
4129 HasErrors = true;
4130 break;
4131 }
4132
4133 // Build update: IS.CounterVar(Private) = IS.Start + Iter * IS.Step
4134 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IS.CounterVar)->getDecl());
4135 auto *CounterVar = buildDeclRefExpr(SemaRef, VD, IS.CounterVar->getType(),
4136 IS.CounterVar->getExprLoc(),
4137 /*RefersToCapture=*/true);
4138 ExprResult Init = BuildCounterInit(SemaRef, CurScope, UpdLoc, CounterVar,
4139 IS.CounterInit, Captures);
4140 if (!Init.isUsable()) {
4141 HasErrors = true;
4142 break;
4143 }
4144 ExprResult Update = BuildCounterUpdate(
4145 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, Iter,
4146 IS.CounterStep, IS.Subtract, &Captures);
4147 if (!Update.isUsable()) {
4148 HasErrors = true;
4149 break;
4150 }
4151
4152 // Build final: IS.CounterVar = IS.Start + IS.NumIters * IS.Step
4153 ExprResult Final = BuildCounterUpdate(
4154 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit,
4155 IS.NumIterations, IS.CounterStep, IS.Subtract, &Captures);
4156 if (!Final.isUsable()) {
4157 HasErrors = true;
4158 break;
4159 }
4160
4161 // Build Div for the next iteration: Div <- Div * IS.NumIters
4162 if (Cnt != 0) {
4163 if (Div.isUnset())
4164 Div = IS.NumIterations;
4165 else
4166 Div = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Mul, Div.get(),
4167 IS.NumIterations);
4168
4169 // Add parentheses (for debugging purposes only).
4170 if (Div.isUsable())
4171 Div = tryBuildCapture(SemaRef, Div.get(), Captures);
4172 if (!Div.isUsable()) {
4173 HasErrors = true;
4174 break;
4175 }
4176 LoopMultipliers.push_back(Div.get());
4177 }
4178 if (!Update.isUsable() || !Final.isUsable()) {
4179 HasErrors = true;
4180 break;
4181 }
4182 // Save results
4183 Built.Counters[Cnt] = IS.CounterVar;
4184 Built.PrivateCounters[Cnt] = IS.PrivateCounterVar;
4185 Built.Inits[Cnt] = Init.get();
4186 Built.Updates[Cnt] = Update.get();
4187 Built.Finals[Cnt] = Final.get();
4188 }
4189 }
4190
4191 if (HasErrors)
4192 return 0;
4193
4194 // Save results
4195 Built.IterationVarRef = IV.get();
4196 Built.LastIteration = LastIteration.get();
4197 Built.NumIterations = NumIterations.get();
4198 Built.CalcLastIteration =
4199 SemaRef.ActOnFinishFullExpr(CalcLastIteration.get()).get();
4200 Built.PreCond = PreCond.get();
4201 Built.PreInits = buildPreInits(C, Captures);
4202 Built.Cond = Cond.get();
4203 Built.Init = Init.get();
4204 Built.Inc = Inc.get();
4205 Built.LB = LB.get();
4206 Built.UB = UB.get();
4207 Built.IL = IL.get();
4208 Built.ST = ST.get();
4209 Built.EUB = EUB.get();
4210 Built.NLB = NextLB.get();
4211 Built.NUB = NextUB.get();
4212 Built.PrevLB = PrevLB.get();
4213 Built.PrevUB = PrevUB.get();
4214
4215 Expr *CounterVal = SemaRef.DefaultLvalueConversion(IV.get()).get();
4216 // Fill data for doacross depend clauses.
4217 for (auto Pair : DSA.getDoacrossDependClauses()) {
4218 if (Pair.first->getDependencyKind() == OMPC_DEPEND_source)
4219 Pair.first->setCounterValue(CounterVal);
4220 else {
4221 if (NestedLoopCount != Pair.second.size() ||
4222 NestedLoopCount != LoopMultipliers.size() + 1) {
4223 // Erroneous case - clause has some problems.
4224 Pair.first->setCounterValue(CounterVal);
4225 continue;
4226 }
4227 assert(Pair.first->getDependencyKind() == OMPC_DEPEND_sink)((Pair.first->getDependencyKind() == OMPC_DEPEND_sink) ? static_cast
<void> (0) : __assert_fail ("Pair.first->getDependencyKind() == OMPC_DEPEND_sink"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4227, __PRETTY_FUNCTION__))
;
4228 auto I = Pair.second.rbegin();
4229 auto IS = IterSpaces.rbegin();
4230 auto ILM = LoopMultipliers.rbegin();
4231 Expr *UpCounterVal = CounterVal;
4232 Expr *Multiplier = nullptr;
4233 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) {
4234 if (I->first) {
4235 assert(IS->CounterStep)((IS->CounterStep) ? static_cast<void> (0) : __assert_fail
("IS->CounterStep", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4235, __PRETTY_FUNCTION__))
;
4236 Expr *NormalizedOffset =
4237 SemaRef
4238 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Div,
4239 I->first, IS->CounterStep)
4240 .get();
4241 if (Multiplier) {
4242 NormalizedOffset =
4243 SemaRef
4244 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Mul,
4245 NormalizedOffset, Multiplier)
4246 .get();
4247 }
4248 assert(I->second == OO_Plus || I->second == OO_Minus)((I->second == OO_Plus || I->second == OO_Minus) ? static_cast
<void> (0) : __assert_fail ("I->second == OO_Plus || I->second == OO_Minus"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4248, __PRETTY_FUNCTION__))
;
4249 BinaryOperatorKind BOK = (I->second == OO_Plus) ? BO_Add : BO_Sub;
4250 UpCounterVal = SemaRef
4251 .BuildBinOp(CurScope, I->first->getExprLoc(), BOK,
4252 UpCounterVal, NormalizedOffset)
4253 .get();
4254 }
4255 Multiplier = *ILM;
4256 ++I;
4257 ++IS;
4258 ++ILM;
4259 }
4260 Pair.first->setCounterValue(UpCounterVal);
4261 }
4262 }
4263
4264 return NestedLoopCount;
4265}
4266
4267static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) {
4268 auto CollapseClauses =
4269 OMPExecutableDirective::getClausesOfKind<OMPCollapseClause>(Clauses);
4270 if (CollapseClauses.begin() != CollapseClauses.end())
4271 return (*CollapseClauses.begin())->getNumForLoops();
4272 return nullptr;
4273}
4274
4275static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) {
4276 auto OrderedClauses =
4277 OMPExecutableDirective::getClausesOfKind<OMPOrderedClause>(Clauses);
4278 if (OrderedClauses.begin() != OrderedClauses.end())
4279 return (*OrderedClauses.begin())->getNumForLoops();
4280 return nullptr;
4281}
4282
4283static bool checkSimdlenSafelenSpecified(Sema &S,
4284 const ArrayRef<OMPClause *> Clauses) {
4285 OMPSafelenClause *Safelen = nullptr;
4286 OMPSimdlenClause *Simdlen = nullptr;
4287
4288 for (auto *Clause : Clauses) {
4289 if (Clause->getClauseKind() == OMPC_safelen)
4290 Safelen = cast<OMPSafelenClause>(Clause);
4291 else if (Clause->getClauseKind() == OMPC_simdlen)
4292 Simdlen = cast<OMPSimdlenClause>(Clause);
4293 if (Safelen && Simdlen)
4294 break;
4295 }
4296
4297 if (Simdlen && Safelen) {
4298 llvm::APSInt SimdlenRes, SafelenRes;
4299 auto SimdlenLength = Simdlen->getSimdlen();
4300 auto SafelenLength = Safelen->getSafelen();
4301 if (SimdlenLength->isValueDependent() || SimdlenLength->isTypeDependent() ||
4302 SimdlenLength->isInstantiationDependent() ||
4303 SimdlenLength->containsUnexpandedParameterPack())
4304 return false;
4305 if (SafelenLength->isValueDependent() || SafelenLength->isTypeDependent() ||
4306 SafelenLength->isInstantiationDependent() ||
4307 SafelenLength->containsUnexpandedParameterPack())
4308 return false;
4309 SimdlenLength->EvaluateAsInt(SimdlenRes, S.Context);
4310 SafelenLength->EvaluateAsInt(SafelenRes, S.Context);
4311 // OpenMP 4.5 [2.8.1, simd Construct, Restrictions]
4312 // If both simdlen and safelen clauses are specified, the value of the
4313 // simdlen parameter must be less than or equal to the value of the safelen
4314 // parameter.
4315 if (SimdlenRes > SafelenRes) {
4316 S.Diag(SimdlenLength->getExprLoc(),
4317 diag::err_omp_wrong_simdlen_safelen_values)
4318 << SimdlenLength->getSourceRange() << SafelenLength->getSourceRange();
4319 return true;
4320 }
4321 }
4322 return false;
4323}
4324
4325StmtResult Sema::ActOnOpenMPSimdDirective(
4326 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4327 SourceLocation EndLoc,
4328 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4329 if (!AStmt)
4330 return StmtError();
4331
4332 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4332, __PRETTY_FUNCTION__))
;
4333 OMPLoopDirective::HelperExprs B;
4334 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4335 // define the nested loops number.
4336 unsigned NestedLoopCount = CheckOpenMPLoop(
4337 OMPD_simd, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
4338 AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, VarsWithImplicitDSA, B);
4339 if (NestedLoopCount == 0)
4340 return StmtError();
4341
4342 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp simd loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4343, __PRETTY_FUNCTION__))
4343 "omp simd loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp simd loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4343, __PRETTY_FUNCTION__))
;
4344
4345 if (!CurContext->isDependentContext()) {
4346 // Finalize the clauses that need pre-built expressions for CodeGen.
4347 for (auto C : Clauses) {
4348 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4349 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4350 B.NumIterations, *this, CurScope,
4351 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
4352 return StmtError();
4353 }
4354 }
4355
4356 if (checkSimdlenSafelenSpecified(*this, Clauses))
4357 return StmtError();
4358
4359 getCurFunction()->setHasBranchProtectedScope();
4360 return OMPSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4361 Clauses, AStmt, B);
4362}
4363
4364StmtResult Sema::ActOnOpenMPForDirective(
4365 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4366 SourceLocation EndLoc,
4367 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4368 if (!AStmt)
4369 return StmtError();
4370
4371 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4371, __PRETTY_FUNCTION__))
;
4372 OMPLoopDirective::HelperExprs B;
4373 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4374 // define the nested loops number.
4375 unsigned NestedLoopCount = CheckOpenMPLoop(
4376 OMPD_for, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses),
4377 AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, VarsWithImplicitDSA, B);
4378 if (NestedLoopCount == 0)
4379 return StmtError();
4380
4381 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4382, __PRETTY_FUNCTION__))
4382 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4382, __PRETTY_FUNCTION__))
;
4383
4384 if (!CurContext->isDependentContext()) {
4385 // Finalize the clauses that need pre-built expressions for CodeGen.
4386 for (auto C : Clauses) {
4387 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4388 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4389 B.NumIterations, *this, CurScope,
4390 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
4391 return StmtError();
4392 }
4393 }
4394
4395 getCurFunction()->setHasBranchProtectedScope();
4396 return OMPForDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4397 Clauses, AStmt, B, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4398}
4399
4400StmtResult Sema::ActOnOpenMPForSimdDirective(
4401 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4402 SourceLocation EndLoc,
4403 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4404 if (!AStmt)
4405 return StmtError();
4406
4407 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4407, __PRETTY_FUNCTION__))
;
4408 OMPLoopDirective::HelperExprs B;
4409 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4410 // define the nested loops number.
4411 unsigned NestedLoopCount =
4412 CheckOpenMPLoop(OMPD_for_simd, getCollapseNumberExpr(Clauses),
4413 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
4414 VarsWithImplicitDSA, B);
4415 if (NestedLoopCount == 0)
4416 return StmtError();
4417
4418 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for simd loop exprs were not built") ? static_cast<void
> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4419, __PRETTY_FUNCTION__))
4419 "omp for simd loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for simd loop exprs were not built") ? static_cast<void
> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4419, __PRETTY_FUNCTION__))
;
4420
4421 if (!CurContext->isDependentContext()) {
4422 // Finalize the clauses that need pre-built expressions for CodeGen.
4423 for (auto C : Clauses) {
4424 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4425 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4426 B.NumIterations, *this, CurScope,
4427 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
4428 return StmtError();
4429 }
4430 }
4431
4432 if (checkSimdlenSafelenSpecified(*this, Clauses))
4433 return StmtError();
4434
4435 getCurFunction()->setHasBranchProtectedScope();
4436 return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount,
4437 Clauses, AStmt, B);
4438}
4439
4440StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
4441 Stmt *AStmt,
4442 SourceLocation StartLoc,
4443 SourceLocation EndLoc) {
4444 if (!AStmt)
4445 return StmtError();
4446
4447 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4447, __PRETTY_FUNCTION__))
;
4448 auto BaseStmt = AStmt;
4449 while (auto *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
4450 BaseStmt = CS->getCapturedStmt();
4451 if (auto *C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
4452 auto S = C->children();
4453 if (S.begin() == S.end())
4454 return StmtError();
4455 // All associated statements must be '#pragma omp section' except for
4456 // the first one.
4457 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
4458 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
4459 if (SectionStmt)
4460 Diag(SectionStmt->getLocStart(),
4461 diag::err_omp_sections_substmt_not_section);
4462 return StmtError();
4463 }
4464 cast<OMPSectionDirective>(SectionStmt)
4465 ->setHasCancel(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4466 }
4467 } else {
4468 Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt);
4469 return StmtError();
4470 }
4471
4472 getCurFunction()->setHasBranchProtectedScope();
4473
4474 return OMPSectionsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
4475 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4476}
4477
4478StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
4479 SourceLocation StartLoc,
4480 SourceLocation EndLoc) {
4481 if (!AStmt)
4482 return StmtError();
4483
4484 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4484, __PRETTY_FUNCTION__))
;
4485
4486 getCurFunction()->setHasBranchProtectedScope();
4487 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setParentCancelRegion(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4488
4489 return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt,
4490 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4491}
4492
4493StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
4494 Stmt *AStmt,
4495 SourceLocation StartLoc,
4496 SourceLocation EndLoc) {
4497 if (!AStmt)
4498 return StmtError();
4499
4500 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4500, __PRETTY_FUNCTION__))
;
4501
4502 getCurFunction()->setHasBranchProtectedScope();
4503
4504 // OpenMP [2.7.3, single Construct, Restrictions]
4505 // The copyprivate clause must not be used with the nowait clause.
4506 OMPClause *Nowait = nullptr;
4507 OMPClause *Copyprivate = nullptr;
4508 for (auto *Clause : Clauses) {
4509 if (Clause->getClauseKind() == OMPC_nowait)
4510 Nowait = Clause;
4511 else if (Clause->getClauseKind() == OMPC_copyprivate)
4512 Copyprivate = Clause;
4513 if (Copyprivate && Nowait) {
4514 Diag(Copyprivate->getLocStart(),
4515 diag::err_omp_single_copyprivate_with_nowait);
4516 Diag(Nowait->getLocStart(), diag::note_omp_nowait_clause_here);
4517 return StmtError();
4518 }
4519 }
4520
4521 return OMPSingleDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
4522}
4523
4524StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
4525 SourceLocation StartLoc,
4526 SourceLocation EndLoc) {
4527 if (!AStmt)
4528 return StmtError();
4529
4530 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4530, __PRETTY_FUNCTION__))
;
4531
4532 getCurFunction()->setHasBranchProtectedScope();
4533
4534 return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt);
4535}
4536
4537StmtResult Sema::ActOnOpenMPCriticalDirective(
4538 const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses,
4539 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
4540 if (!AStmt)
4541 return StmtError();
4542
4543 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4543, __PRETTY_FUNCTION__))
;
4544
4545 bool ErrorFound = false;
4546 llvm::APSInt Hint;
4547 SourceLocation HintLoc;
4548 bool DependentHint = false;
4549 for (auto *C : Clauses) {
4550 if (C->getClauseKind() == OMPC_hint) {
4551 if (!DirName.getName()) {
4552 Diag(C->getLocStart(), diag::err_omp_hint_clause_no_name);
4553 ErrorFound = true;
4554 }
4555 Expr *E = cast<OMPHintClause>(C)->getHint();
4556 if (E->isTypeDependent() || E->isValueDependent() ||
4557 E->isInstantiationDependent())
4558 DependentHint = true;
4559 else {
4560 Hint = E->EvaluateKnownConstInt(Context);
4561 HintLoc = C->getLocStart();
4562 }
4563 }
4564 }
4565 if (ErrorFound)
4566 return StmtError();
4567 auto Pair = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCriticalWithHint(DirName);
4568 if (Pair.first && DirName.getName() && !DependentHint) {
4569 if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {
4570 Diag(StartLoc, diag::err_omp_critical_with_hint);
4571 if (HintLoc.isValid()) {
4572 Diag(HintLoc, diag::note_omp_critical_hint_here)
4573 << 0 << Hint.toString(/*Radix=*/10, /*Signed=*/false);
4574 } else
4575 Diag(StartLoc, diag::note_omp_critical_no_hint) << 0;
4576 if (auto *C = Pair.first->getSingleClause<OMPHintClause>()) {
4577 Diag(C->getLocStart(), diag::note_omp_critical_hint_here)
4578 << 1
4579 << C->getHint()->EvaluateKnownConstInt(Context).toString(
4580 /*Radix=*/10, /*Signed=*/false);
4581 } else
4582 Diag(Pair.first->getLocStart(), diag::note_omp_critical_no_hint) << 1;
4583 }
4584 }
4585
4586 getCurFunction()->setHasBranchProtectedScope();
4587
4588 auto *Dir = OMPCriticalDirective::Create(Context, DirName, StartLoc, EndLoc,
4589 Clauses, AStmt);
4590 if (!Pair.first && DirName.getName() && !DependentHint)
4591 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->addCriticalWithHint(Dir, Hint);
4592 return Dir;
4593}
4594
4595StmtResult Sema::ActOnOpenMPParallelForDirective(
4596 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4597 SourceLocation EndLoc,
4598 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4599 if (!AStmt)
4600 return StmtError();
4601
4602 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
4603 // 1.2.2 OpenMP Language Terminology
4604 // Structured block - An executable statement with a single entry at the
4605 // top and a single exit at the bottom.
4606 // The point of exit cannot be a branch out of the structured block.
4607 // longjmp() and throw() must not violate the entry/exit criteria.
4608 CS->getCapturedDecl()->setNothrow();
4609
4610 OMPLoopDirective::HelperExprs B;
4611 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4612 // define the nested loops number.
4613 unsigned NestedLoopCount =
4614 CheckOpenMPLoop(OMPD_parallel_for, getCollapseNumberExpr(Clauses),
4615 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
4616 VarsWithImplicitDSA, B);
4617 if (NestedLoopCount == 0)
4618 return StmtError();
4619
4620 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp parallel for loop exprs were not built") ? static_cast<
void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp parallel for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4621, __PRETTY_FUNCTION__))
4621 "omp parallel for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp parallel for loop exprs were not built") ? static_cast<
void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp parallel for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4621, __PRETTY_FUNCTION__))
;
4622
4623 if (!CurContext->isDependentContext()) {
4624 // Finalize the clauses that need pre-built expressions for CodeGen.
4625 for (auto C : Clauses) {
4626 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4627 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4628 B.NumIterations, *this, CurScope,
4629 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
4630 return StmtError();
4631 }
4632 }
4633
4634 getCurFunction()->setHasBranchProtectedScope();
4635 return OMPParallelForDirective::Create(Context, StartLoc, EndLoc,
4636 NestedLoopCount, Clauses, AStmt, B,
4637 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4638}
4639
4640StmtResult Sema::ActOnOpenMPParallelForSimdDirective(
4641 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
4642 SourceLocation EndLoc,
4643 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
4644 if (!AStmt)
4645 return StmtError();
4646
4647 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
4648 // 1.2.2 OpenMP Language Terminology
4649 // Structured block - An executable statement with a single entry at the
4650 // top and a single exit at the bottom.
4651 // The point of exit cannot be a branch out of the structured block.
4652 // longjmp() and throw() must not violate the entry/exit criteria.
4653 CS->getCapturedDecl()->setNothrow();
4654
4655 OMPLoopDirective::HelperExprs B;
4656 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
4657 // define the nested loops number.
4658 unsigned NestedLoopCount =
4659 CheckOpenMPLoop(OMPD_parallel_for_simd, getCollapseNumberExpr(Clauses),
4660 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
4661 VarsWithImplicitDSA, B);
4662 if (NestedLoopCount == 0)
4663 return StmtError();
4664
4665 if (!CurContext->isDependentContext()) {
4666 // Finalize the clauses that need pre-built expressions for CodeGen.
4667 for (auto C : Clauses) {
4668 if (auto *LC = dyn_cast<OMPLinearClause>(C))
4669 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
4670 B.NumIterations, *this, CurScope,
4671 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
4672 return StmtError();
4673 }
4674 }
4675
4676 if (checkSimdlenSafelenSpecified(*this, Clauses))
4677 return StmtError();
4678
4679 getCurFunction()->setHasBranchProtectedScope();
4680 return OMPParallelForSimdDirective::Create(
4681 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
4682}
4683
4684StmtResult
4685Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
4686 Stmt *AStmt, SourceLocation StartLoc,
4687 SourceLocation EndLoc) {
4688 if (!AStmt)
4689 return StmtError();
4690
4691 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4691, __PRETTY_FUNCTION__))
;
4692 auto BaseStmt = AStmt;
4693 while (auto *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt))
4694 BaseStmt = CS->getCapturedStmt();
4695 if (auto *C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) {
4696 auto S = C->children();
4697 if (S.begin() == S.end())
4698 return StmtError();
4699 // All associated statements must be '#pragma omp section' except for
4700 // the first one.
4701 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
4702 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
4703 if (SectionStmt)
4704 Diag(SectionStmt->getLocStart(),
4705 diag::err_omp_parallel_sections_substmt_not_section);
4706 return StmtError();
4707 }
4708 cast<OMPSectionDirective>(SectionStmt)
4709 ->setHasCancel(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4710 }
4711 } else {
4712 Diag(AStmt->getLocStart(),
4713 diag::err_omp_parallel_sections_not_compound_stmt);
4714 return StmtError();
4715 }
4716
4717 getCurFunction()->setHasBranchProtectedScope();
4718
4719 return OMPParallelSectionsDirective::Create(
4720 Context, StartLoc, EndLoc, Clauses, AStmt, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4721}
4722
4723StmtResult Sema::ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
4724 Stmt *AStmt, SourceLocation StartLoc,
4725 SourceLocation EndLoc) {
4726 if (!AStmt)
4727 return StmtError();
4728
4729 auto *CS = cast<CapturedStmt>(AStmt);
4730 // 1.2.2 OpenMP Language Terminology
4731 // Structured block - An executable statement with a single entry at the
4732 // top and a single exit at the bottom.
4733 // The point of exit cannot be a branch out of the structured block.
4734 // longjmp() and throw() must not violate the entry/exit criteria.
4735 CS->getCapturedDecl()->setNothrow();
4736
4737 getCurFunction()->setHasBranchProtectedScope();
4738
4739 return OMPTaskDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
4740 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
4741}
4742
4743StmtResult Sema::ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
4744 SourceLocation EndLoc) {
4745 return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc);
4746}
4747
4748StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
4749 SourceLocation EndLoc) {
4750 return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
4751}
4752
4753StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
4754 SourceLocation EndLoc) {
4755 return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc);
4756}
4757
4758StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt,
4759 SourceLocation StartLoc,
4760 SourceLocation EndLoc) {
4761 if (!AStmt)
4762 return StmtError();
4763
4764 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4764, __PRETTY_FUNCTION__))
;
4765
4766 getCurFunction()->setHasBranchProtectedScope();
4767
4768 return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt);
4769}
4770
4771StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
4772 SourceLocation StartLoc,
4773 SourceLocation EndLoc) {
4774 assert(Clauses.size() <= 1 && "Extra clauses in flush directive")((Clauses.size() <= 1 && "Extra clauses in flush directive"
) ? static_cast<void> (0) : __assert_fail ("Clauses.size() <= 1 && \"Extra clauses in flush directive\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4774, __PRETTY_FUNCTION__))
;
4775 return OMPFlushDirective::Create(Context, StartLoc, EndLoc, Clauses);
4776}
4777
4778StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
4779 Stmt *AStmt,
4780 SourceLocation StartLoc,
4781 SourceLocation EndLoc) {
4782 OMPClause *DependFound = nullptr;
4783 OMPClause *DependSourceClause = nullptr;
4784 OMPClause *DependSinkClause = nullptr;
4785 bool ErrorFound = false;
4786 OMPThreadsClause *TC = nullptr;
4787 OMPSIMDClause *SC = nullptr;
4788 for (auto *C : Clauses) {
4789 if (auto *DC = dyn_cast<OMPDependClause>(C)) {
4790 DependFound = C;
4791 if (DC->getDependencyKind() == OMPC_DEPEND_source) {
4792 if (DependSourceClause) {
4793 Diag(C->getLocStart(), diag::err_omp_more_one_clause)
4794 << getOpenMPDirectiveName(OMPD_ordered)
4795 << getOpenMPClauseName(OMPC_depend) << 2;
4796 ErrorFound = true;
4797 } else
4798 DependSourceClause = C;
4799 if (DependSinkClause) {
4800 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
4801 << 0;
4802 ErrorFound = true;
4803 }
4804 } else if (DC->getDependencyKind() == OMPC_DEPEND_sink) {
4805 if (DependSourceClause) {
4806 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed)
4807 << 1;
4808 ErrorFound = true;
4809 }
4810 DependSinkClause = C;
4811 }
4812 } else if (C->getClauseKind() == OMPC_threads)
4813 TC = cast<OMPThreadsClause>(C);
4814 else if (C->getClauseKind() == OMPC_simd)
4815 SC = cast<OMPSIMDClause>(C);
4816 }
4817 if (!ErrorFound && !SC &&
4818 isOpenMPSimdDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getParentDirective())) {
4819 // OpenMP [2.8.1,simd Construct, Restrictions]
4820 // An ordered construct with the simd clause is the only OpenMP construct
4821 // that can appear in the simd region.
4822 Diag(StartLoc, diag::err_omp_prohibited_region_simd);
4823 ErrorFound = true;
4824 } else if (DependFound && (TC || SC)) {
4825 Diag(DependFound->getLocStart(), diag::err_omp_depend_clause_thread_simd)
4826 << getOpenMPClauseName(TC ? TC->getClauseKind() : SC->getClauseKind());
4827 ErrorFound = true;
4828 } else if (DependFound && !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getParentOrderedRegionParam()) {
4829 Diag(DependFound->getLocStart(),
4830 diag::err_omp_ordered_directive_without_param);
4831 ErrorFound = true;
4832 } else if (TC || Clauses.empty()) {
4833 if (auto *Param = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getParentOrderedRegionParam()) {
4834 SourceLocation ErrLoc = TC ? TC->getLocStart() : StartLoc;
4835 Diag(ErrLoc, diag::err_omp_ordered_directive_with_param)
4836 << (TC != nullptr);
4837 Diag(Param->getLocStart(), diag::note_omp_ordered_param);
4838 ErrorFound = true;
4839 }
4840 }
4841 if ((!AStmt && !DependFound) || ErrorFound)
4842 return StmtError();
4843
4844 if (AStmt) {
4845 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 4845, __PRETTY_FUNCTION__))
;
4846
4847 getCurFunction()->setHasBranchProtectedScope();
4848 }
4849
4850 return OMPOrderedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
4851}
4852
4853namespace {
4854/// \brief Helper class for checking expression in 'omp atomic [update]'
4855/// construct.
4856class OpenMPAtomicUpdateChecker {
4857 /// \brief Error results for atomic update expressions.
4858 enum ExprAnalysisErrorCode {
4859 /// \brief A statement is not an expression statement.
4860 NotAnExpression,
4861 /// \brief Expression is not builtin binary or unary operation.
4862 NotABinaryOrUnaryExpression,
4863 /// \brief Unary operation is not post-/pre- increment/decrement operation.
4864 NotAnUnaryIncDecExpression,
4865 /// \brief An expression is not of scalar type.
4866 NotAScalarType,
4867 /// \brief A binary operation is not an assignment operation.
4868 NotAnAssignmentOp,
4869 /// \brief RHS part of the binary operation is not a binary expression.
4870 NotABinaryExpression,
4871 /// \brief RHS part is not additive/multiplicative/shift/biwise binary
4872 /// expression.
4873 NotABinaryOperator,
4874 /// \brief RHS binary operation does not have reference to the updated LHS
4875 /// part.
4876 NotAnUpdateExpression,
4877 /// \brief No errors is found.
4878 NoError
4879 };
4880 /// \brief Reference to Sema.
4881 Sema &SemaRef;
4882 /// \brief A location for note diagnostics (when error is found).
4883 SourceLocation NoteLoc;
4884 /// \brief 'x' lvalue part of the source atomic expression.
4885 Expr *X;
4886 /// \brief 'expr' rvalue part of the source atomic expression.
4887 Expr *E;
4888 /// \brief Helper expression of the form
4889 /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
4890 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
4891 Expr *UpdateExpr;
4892 /// \brief Is 'x' a LHS in a RHS part of full update expression. It is
4893 /// important for non-associative operations.
4894 bool IsXLHSInRHSPart;
4895 BinaryOperatorKind Op;
4896 SourceLocation OpLoc;
4897 /// \brief true if the source expression is a postfix unary operation, false
4898 /// if it is a prefix unary operation.
4899 bool IsPostfixUpdate;
4900
4901public:
4902 OpenMPAtomicUpdateChecker(Sema &SemaRef)
4903 : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr),
4904 IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {}
4905 /// \brief Check specified statement that it is suitable for 'atomic update'
4906 /// constructs and extract 'x', 'expr' and Operation from the original
4907 /// expression. If DiagId and NoteId == 0, then only check is performed
4908 /// without error notification.
4909 /// \param DiagId Diagnostic which should be emitted if error is found.
4910 /// \param NoteId Diagnostic note for the main error message.
4911 /// \return true if statement is not an update expression, false otherwise.
4912 bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0);
4913 /// \brief Return the 'x' lvalue part of the source atomic expression.
4914 Expr *getX() const { return X; }
4915 /// \brief Return the 'expr' rvalue part of the source atomic expression.
4916 Expr *getExpr() const { return E; }
4917 /// \brief Return the update expression used in calculation of the updated
4918 /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
4919 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
4920 Expr *getUpdateExpr() const { return UpdateExpr; }
4921 /// \brief Return true if 'x' is LHS in RHS part of full update expression,
4922 /// false otherwise.
4923 bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
4924
4925 /// \brief true if the source expression is a postfix unary operation, false
4926 /// if it is a prefix unary operation.
4927 bool isPostfixUpdate() const { return IsPostfixUpdate; }
4928
4929private:
4930 bool checkBinaryOperation(BinaryOperator *AtomicBinOp, unsigned DiagId = 0,
4931 unsigned NoteId = 0);
4932};
4933} // namespace
4934
4935bool OpenMPAtomicUpdateChecker::checkBinaryOperation(
4936 BinaryOperator *AtomicBinOp, unsigned DiagId, unsigned NoteId) {
4937 ExprAnalysisErrorCode ErrorFound = NoError;
4938 SourceLocation ErrorLoc, NoteLoc;
4939 SourceRange ErrorRange, NoteRange;
4940 // Allowed constructs are:
4941 // x = x binop expr;
4942 // x = expr binop x;
4943 if (AtomicBinOp->getOpcode() == BO_Assign) {
4944 X = AtomicBinOp->getLHS();
4945 if (auto *AtomicInnerBinOp = dyn_cast<BinaryOperator>(
4946 AtomicBinOp->getRHS()->IgnoreParenImpCasts())) {
4947 if (AtomicInnerBinOp->isMultiplicativeOp() ||
4948 AtomicInnerBinOp->isAdditiveOp() || AtomicInnerBinOp->isShiftOp() ||
4949 AtomicInnerBinOp->isBitwiseOp()) {
4950 Op = AtomicInnerBinOp->getOpcode();
4951 OpLoc = AtomicInnerBinOp->getOperatorLoc();
4952 auto *LHS = AtomicInnerBinOp->getLHS();
4953 auto *RHS = AtomicInnerBinOp->getRHS();
4954 llvm::FoldingSetNodeID XId, LHSId, RHSId;
4955 X->IgnoreParenImpCasts()->Profile(XId, SemaRef.getASTContext(),
4956 /*Canonical=*/true);
4957 LHS->IgnoreParenImpCasts()->Profile(LHSId, SemaRef.getASTContext(),
4958 /*Canonical=*/true);
4959 RHS->IgnoreParenImpCasts()->Profile(RHSId, SemaRef.getASTContext(),
4960 /*Canonical=*/true);
4961 if (XId == LHSId) {
4962 E = RHS;
4963 IsXLHSInRHSPart = true;
4964 } else if (XId == RHSId) {
4965 E = LHS;
4966 IsXLHSInRHSPart = false;
4967 } else {
4968 ErrorLoc = AtomicInnerBinOp->getExprLoc();
4969 ErrorRange = AtomicInnerBinOp->getSourceRange();
4970 NoteLoc = X->getExprLoc();
4971 NoteRange = X->getSourceRange();
4972 ErrorFound = NotAnUpdateExpression;
4973 }
4974 } else {
4975 ErrorLoc = AtomicInnerBinOp->getExprLoc();
4976 ErrorRange = AtomicInnerBinOp->getSourceRange();
4977 NoteLoc = AtomicInnerBinOp->getOperatorLoc();
4978 NoteRange = SourceRange(NoteLoc, NoteLoc);
4979 ErrorFound = NotABinaryOperator;
4980 }
4981 } else {
4982 NoteLoc = ErrorLoc = AtomicBinOp->getRHS()->getExprLoc();
4983 NoteRange = ErrorRange = AtomicBinOp->getRHS()->getSourceRange();
4984 ErrorFound = NotABinaryExpression;
4985 }
4986 } else {
4987 ErrorLoc = AtomicBinOp->getExprLoc();
4988 ErrorRange = AtomicBinOp->getSourceRange();
4989 NoteLoc = AtomicBinOp->getOperatorLoc();
4990 NoteRange = SourceRange(NoteLoc, NoteLoc);
4991 ErrorFound = NotAnAssignmentOp;
4992 }
4993 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
4994 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
4995 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
4996 return true;
4997 } else if (SemaRef.CurContext->isDependentContext())
4998 E = X = UpdateExpr = nullptr;
4999 return ErrorFound != NoError;
5000}
5001
5002bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
5003 unsigned NoteId) {
5004 ExprAnalysisErrorCode ErrorFound = NoError;
5005 SourceLocation ErrorLoc, NoteLoc;
5006 SourceRange ErrorRange, NoteRange;
5007 // Allowed constructs are:
5008 // x++;
5009 // x--;
5010 // ++x;
5011 // --x;
5012 // x binop= expr;
5013 // x = x binop expr;
5014 // x = expr binop x;
5015 if (auto *AtomicBody = dyn_cast<Expr>(S)) {
5016 AtomicBody = AtomicBody->IgnoreParenImpCasts();
5017 if (AtomicBody->getType()->isScalarType() ||
5018 AtomicBody->isInstantiationDependent()) {
5019 if (auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>(
5020 AtomicBody->IgnoreParenImpCasts())) {
5021 // Check for Compound Assignment Operation
5022 Op = BinaryOperator::getOpForCompoundAssignment(
5023 AtomicCompAssignOp->getOpcode());
5024 OpLoc = AtomicCompAssignOp->getOperatorLoc();
5025 E = AtomicCompAssignOp->getRHS();
5026 X = AtomicCompAssignOp->getLHS()->IgnoreParens();
5027 IsXLHSInRHSPart = true;
5028 } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>(
5029 AtomicBody->IgnoreParenImpCasts())) {
5030 // Check for Binary Operation
5031 if (checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
5032 return true;
5033 } else if (auto *AtomicUnaryOp = dyn_cast<UnaryOperator>(
5034 AtomicBody->IgnoreParenImpCasts())) {
5035 // Check for Unary Operation
5036 if (AtomicUnaryOp->isIncrementDecrementOp()) {
5037 IsPostfixUpdate = AtomicUnaryOp->isPostfix();
5038 Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub;
5039 OpLoc = AtomicUnaryOp->getOperatorLoc();
5040 X = AtomicUnaryOp->getSubExpr()->IgnoreParens();
5041 E = SemaRef.ActOnIntegerConstant(OpLoc, /*uint64_t Val=*/1).get();
5042 IsXLHSInRHSPart = true;
5043 } else {
5044 ErrorFound = NotAnUnaryIncDecExpression;
5045 ErrorLoc = AtomicUnaryOp->getExprLoc();
5046 ErrorRange = AtomicUnaryOp->getSourceRange();
5047 NoteLoc = AtomicUnaryOp->getOperatorLoc();
5048 NoteRange = SourceRange(NoteLoc, NoteLoc);
5049 }
5050 } else if (!AtomicBody->isInstantiationDependent()) {
5051 ErrorFound = NotABinaryOrUnaryExpression;
5052 NoteLoc = ErrorLoc = AtomicBody->getExprLoc();
5053 NoteRange = ErrorRange = AtomicBody->getSourceRange();
5054 }
5055 } else {
5056 ErrorFound = NotAScalarType;
5057 NoteLoc = ErrorLoc = AtomicBody->getLocStart();
5058 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5059 }
5060 } else {
5061 ErrorFound = NotAnExpression;
5062 NoteLoc = ErrorLoc = S->getLocStart();
5063 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5064 }
5065 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) {
5066 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange;
5067 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange;
5068 return true;
5069 } else if (SemaRef.CurContext->isDependentContext())
5070 E = X = UpdateExpr = nullptr;
5071 if (ErrorFound == NoError && E && X) {
5072 // Build an update expression of form 'OpaqueValueExpr(x) binop
5073 // OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop
5074 // OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression.
5075 auto *OVEX = new (SemaRef.getASTContext())
5076 OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue);
5077 auto *OVEExpr = new (SemaRef.getASTContext())
5078 OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue);
5079 auto Update =
5080 SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr,
5081 IsXLHSInRHSPart ? OVEExpr : OVEX);
5082 if (Update.isInvalid())
5083 return true;
5084 Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(),
5085 Sema::AA_Casting);
5086 if (Update.isInvalid())
5087 return true;
5088 UpdateExpr = Update.get();
5089 }
5090 return ErrorFound != NoError;
5091}
5092
5093StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
5094 Stmt *AStmt,
5095 SourceLocation StartLoc,
5096 SourceLocation EndLoc) {
5097 if (!AStmt)
5098 return StmtError();
5099
5100 auto *CS = cast<CapturedStmt>(AStmt);
5101 // 1.2.2 OpenMP Language Terminology
5102 // Structured block - An executable statement with a single entry at the
5103 // top and a single exit at the bottom.
5104 // The point of exit cannot be a branch out of the structured block.
5105 // longjmp() and throw() must not violate the entry/exit criteria.
5106 OpenMPClauseKind AtomicKind = OMPC_unknown;
5107 SourceLocation AtomicKindLoc;
5108 for (auto *C : Clauses) {
5109 if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write ||
5110 C->getClauseKind() == OMPC_update ||
5111 C->getClauseKind() == OMPC_capture) {
5112 if (AtomicKind != OMPC_unknown) {
5113 Diag(C->getLocStart(), diag::err_omp_atomic_several_clauses)
5114 << SourceRange(C->getLocStart(), C->getLocEnd());
5115 Diag(AtomicKindLoc, diag::note_omp_atomic_previous_clause)
5116 << getOpenMPClauseName(AtomicKind);
5117 } else {
5118 AtomicKind = C->getClauseKind();
5119 AtomicKindLoc = C->getLocStart();
5120 }
5121 }
5122 }
5123
5124 auto Body = CS->getCapturedStmt();
5125 if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
5126 Body = EWC->getSubExpr();
5127
5128 Expr *X = nullptr;
5129 Expr *V = nullptr;
5130 Expr *E = nullptr;
5131 Expr *UE = nullptr;
5132 bool IsXLHSInRHSPart = false;
5133 bool IsPostfixUpdate = false;
5134 // OpenMP [2.12.6, atomic Construct]
5135 // In the next expressions:
5136 // * x and v (as applicable) are both l-value expressions with scalar type.
5137 // * During the execution of an atomic region, multiple syntactic
5138 // occurrences of x must designate the same storage location.
5139 // * Neither of v and expr (as applicable) may access the storage location
5140 // designated by x.
5141 // * Neither of x and expr (as applicable) may access the storage location
5142 // designated by v.
5143 // * expr is an expression with scalar type.
5144 // * binop is one of +, *, -, /, &, ^, |, <<, or >>.
5145 // * binop, binop=, ++, and -- are not overloaded operators.
5146 // * The expression x binop expr must be numerically equivalent to x binop
5147 // (expr). This requirement is satisfied if the operators in expr have
5148 // precedence greater than binop, or by using parentheses around expr or
5149 // subexpressions of expr.
5150 // * The expression expr binop x must be numerically equivalent to (expr)
5151 // binop x. This requirement is satisfied if the operators in expr have
5152 // precedence equal to or greater than binop, or by using parentheses around
5153 // expr or subexpressions of expr.
5154 // * For forms that allow multiple occurrences of x, the number of times
5155 // that x is evaluated is unspecified.
5156 if (AtomicKind == OMPC_read) {
5157 enum {
5158 NotAnExpression,
5159 NotAnAssignmentOp,
5160 NotAScalarType,
5161 NotAnLValue,
5162 NoError
5163 } ErrorFound = NoError;
5164 SourceLocation ErrorLoc, NoteLoc;
5165 SourceRange ErrorRange, NoteRange;
5166 // If clause is read:
5167 // v = x;
5168 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5169 auto *AtomicBinOp =
5170 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5171 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5172 X = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
5173 V = AtomicBinOp->getLHS()->IgnoreParenImpCasts();
5174 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
5175 (V->isInstantiationDependent() || V->getType()->isScalarType())) {
5176 if (!X->isLValue() || !V->isLValue()) {
5177 auto NotLValueExpr = X->isLValue() ? V : X;
5178 ErrorFound = NotAnLValue;
5179 ErrorLoc = AtomicBinOp->getExprLoc();
5180 ErrorRange = AtomicBinOp->getSourceRange();
5181 NoteLoc = NotLValueExpr->getExprLoc();
5182 NoteRange = NotLValueExpr->getSourceRange();
5183 }
5184 } else if (!X->isInstantiationDependent() ||
5185 !V->isInstantiationDependent()) {
5186 auto NotScalarExpr =
5187 (X->isInstantiationDependent() || X->getType()->isScalarType())
5188 ? V
5189 : X;
5190 ErrorFound = NotAScalarType;
5191 ErrorLoc = AtomicBinOp->getExprLoc();
5192 ErrorRange = AtomicBinOp->getSourceRange();
5193 NoteLoc = NotScalarExpr->getExprLoc();
5194 NoteRange = NotScalarExpr->getSourceRange();
5195 }
5196 } else if (!AtomicBody->isInstantiationDependent()) {
5197 ErrorFound = NotAnAssignmentOp;
5198 ErrorLoc = AtomicBody->getExprLoc();
5199 ErrorRange = AtomicBody->getSourceRange();
5200 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5201 : AtomicBody->getExprLoc();
5202 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5203 : AtomicBody->getSourceRange();
5204 }
5205 } else {
5206 ErrorFound = NotAnExpression;
5207 NoteLoc = ErrorLoc = Body->getLocStart();
5208 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5209 }
5210 if (ErrorFound != NoError) {
5211 Diag(ErrorLoc, diag::err_omp_atomic_read_not_expression_statement)
5212 << ErrorRange;
5213 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
5214 << NoteRange;
5215 return StmtError();
5216 } else if (CurContext->isDependentContext())
5217 V = X = nullptr;
5218 } else if (AtomicKind == OMPC_write) {
5219 enum {
5220 NotAnExpression,
5221 NotAnAssignmentOp,
5222 NotAScalarType,
5223 NotAnLValue,
5224 NoError
5225 } ErrorFound = NoError;
5226 SourceLocation ErrorLoc, NoteLoc;
5227 SourceRange ErrorRange, NoteRange;
5228 // If clause is write:
5229 // x = expr;
5230 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5231 auto *AtomicBinOp =
5232 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5233 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5234 X = AtomicBinOp->getLHS();
5235 E = AtomicBinOp->getRHS();
5236 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) &&
5237 (E->isInstantiationDependent() || E->getType()->isScalarType())) {
5238 if (!X->isLValue()) {
5239 ErrorFound = NotAnLValue;
5240 ErrorLoc = AtomicBinOp->getExprLoc();
5241 ErrorRange = AtomicBinOp->getSourceRange();
5242 NoteLoc = X->getExprLoc();
5243 NoteRange = X->getSourceRange();
5244 }
5245 } else if (!X->isInstantiationDependent() ||
5246 !E->isInstantiationDependent()) {
5247 auto NotScalarExpr =
5248 (X->isInstantiationDependent() || X->getType()->isScalarType())
5249 ? E
5250 : X;
5251 ErrorFound = NotAScalarType;
5252 ErrorLoc = AtomicBinOp->getExprLoc();
5253 ErrorRange = AtomicBinOp->getSourceRange();
5254 NoteLoc = NotScalarExpr->getExprLoc();
5255 NoteRange = NotScalarExpr->getSourceRange();
5256 }
5257 } else if (!AtomicBody->isInstantiationDependent()) {
5258 ErrorFound = NotAnAssignmentOp;
5259 ErrorLoc = AtomicBody->getExprLoc();
5260 ErrorRange = AtomicBody->getSourceRange();
5261 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5262 : AtomicBody->getExprLoc();
5263 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5264 : AtomicBody->getSourceRange();
5265 }
5266 } else {
5267 ErrorFound = NotAnExpression;
5268 NoteLoc = ErrorLoc = Body->getLocStart();
5269 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc);
5270 }
5271 if (ErrorFound != NoError) {
5272 Diag(ErrorLoc, diag::err_omp_atomic_write_not_expression_statement)
5273 << ErrorRange;
5274 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound
5275 << NoteRange;
5276 return StmtError();
5277 } else if (CurContext->isDependentContext())
5278 E = X = nullptr;
5279 } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {
5280 // If clause is update:
5281 // x++;
5282 // x--;
5283 // ++x;
5284 // --x;
5285 // x binop= expr;
5286 // x = x binop expr;
5287 // x = expr binop x;
5288 OpenMPAtomicUpdateChecker Checker(*this);
5289 if (Checker.checkStatement(
5290 Body, (AtomicKind == OMPC_update)
5291 ? diag::err_omp_atomic_update_not_expression_statement
5292 : diag::err_omp_atomic_not_expression_statement,
5293 diag::note_omp_atomic_update))
5294 return StmtError();
5295 if (!CurContext->isDependentContext()) {
5296 E = Checker.getExpr();
5297 X = Checker.getX();
5298 UE = Checker.getUpdateExpr();
5299 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5300 }
5301 } else if (AtomicKind == OMPC_capture) {
5302 enum {
5303 NotAnAssignmentOp,
5304 NotACompoundStatement,
5305 NotTwoSubstatements,
5306 NotASpecificExpression,
5307 NoError
5308 } ErrorFound = NoError;
5309 SourceLocation ErrorLoc, NoteLoc;
5310 SourceRange ErrorRange, NoteRange;
5311 if (auto *AtomicBody = dyn_cast<Expr>(Body)) {
5312 // If clause is a capture:
5313 // v = x++;
5314 // v = x--;
5315 // v = ++x;
5316 // v = --x;
5317 // v = x binop= expr;
5318 // v = x = x binop expr;
5319 // v = x = expr binop x;
5320 auto *AtomicBinOp =
5321 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts());
5322 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {
5323 V = AtomicBinOp->getLHS();
5324 Body = AtomicBinOp->getRHS()->IgnoreParenImpCasts();
5325 OpenMPAtomicUpdateChecker Checker(*this);
5326 if (Checker.checkStatement(
5327 Body, diag::err_omp_atomic_capture_not_expression_statement,
5328 diag::note_omp_atomic_update))
5329 return StmtError();
5330 E = Checker.getExpr();
5331 X = Checker.getX();
5332 UE = Checker.getUpdateExpr();
5333 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5334 IsPostfixUpdate = Checker.isPostfixUpdate();
5335 } else if (!AtomicBody->isInstantiationDependent()) {
5336 ErrorLoc = AtomicBody->getExprLoc();
5337 ErrorRange = AtomicBody->getSourceRange();
5338 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc()
5339 : AtomicBody->getExprLoc();
5340 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange()
5341 : AtomicBody->getSourceRange();
5342 ErrorFound = NotAnAssignmentOp;
5343 }
5344 if (ErrorFound != NoError) {
5345 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_expression_statement)
5346 << ErrorRange;
5347 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
5348 return StmtError();
5349 } else if (CurContext->isDependentContext()) {
5350 UE = V = E = X = nullptr;
5351 }
5352 } else {
5353 // If clause is a capture:
5354 // { v = x; x = expr; }
5355 // { v = x; x++; }
5356 // { v = x; x--; }
5357 // { v = x; ++x; }
5358 // { v = x; --x; }
5359 // { v = x; x binop= expr; }
5360 // { v = x; x = x binop expr; }
5361 // { v = x; x = expr binop x; }
5362 // { x++; v = x; }
5363 // { x--; v = x; }
5364 // { ++x; v = x; }
5365 // { --x; v = x; }
5366 // { x binop= expr; v = x; }
5367 // { x = x binop expr; v = x; }
5368 // { x = expr binop x; v = x; }
5369 if (auto *CS = dyn_cast<CompoundStmt>(Body)) {
5370 // Check that this is { expr1; expr2; }
5371 if (CS->size() == 2) {
5372 auto *First = CS->body_front();
5373 auto *Second = CS->body_back();
5374 if (auto *EWC = dyn_cast<ExprWithCleanups>(First))
5375 First = EWC->getSubExpr()->IgnoreParenImpCasts();
5376 if (auto *EWC = dyn_cast<ExprWithCleanups>(Second))
5377 Second = EWC->getSubExpr()->IgnoreParenImpCasts();
5378 // Need to find what subexpression is 'v' and what is 'x'.
5379 OpenMPAtomicUpdateChecker Checker(*this);
5380 bool IsUpdateExprFound = !Checker.checkStatement(Second);
5381 BinaryOperator *BinOp = nullptr;
5382 if (IsUpdateExprFound) {
5383 BinOp = dyn_cast<BinaryOperator>(First);
5384 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
5385 }
5386 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
5387 // { v = x; x++; }
5388 // { v = x; x--; }
5389 // { v = x; ++x; }
5390 // { v = x; --x; }
5391 // { v = x; x binop= expr; }
5392 // { v = x; x = x binop expr; }
5393 // { v = x; x = expr binop x; }
5394 // Check that the first expression has form v = x.
5395 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
5396 llvm::FoldingSetNodeID XId, PossibleXId;
5397 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
5398 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
5399 IsUpdateExprFound = XId == PossibleXId;
5400 if (IsUpdateExprFound) {
5401 V = BinOp->getLHS();
5402 X = Checker.getX();
5403 E = Checker.getExpr();
5404 UE = Checker.getUpdateExpr();
5405 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5406 IsPostfixUpdate = true;
5407 }
5408 }
5409 if (!IsUpdateExprFound) {
5410 IsUpdateExprFound = !Checker.checkStatement(First);
5411 BinOp = nullptr;
5412 if (IsUpdateExprFound) {
5413 BinOp = dyn_cast<BinaryOperator>(Second);
5414 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign;
5415 }
5416 if (IsUpdateExprFound && !CurContext->isDependentContext()) {
5417 // { x++; v = x; }
5418 // { x--; v = x; }
5419 // { ++x; v = x; }
5420 // { --x; v = x; }
5421 // { x binop= expr; v = x; }
5422 // { x = x binop expr; v = x; }
5423 // { x = expr binop x; v = x; }
5424 // Check that the second expression has form v = x.
5425 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts();
5426 llvm::FoldingSetNodeID XId, PossibleXId;
5427 Checker.getX()->Profile(XId, Context, /*Canonical=*/true);
5428 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true);
5429 IsUpdateExprFound = XId == PossibleXId;
5430 if (IsUpdateExprFound) {
5431 V = BinOp->getLHS();
5432 X = Checker.getX();
5433 E = Checker.getExpr();
5434 UE = Checker.getUpdateExpr();
5435 IsXLHSInRHSPart = Checker.isXLHSInRHSPart();
5436 IsPostfixUpdate = false;
5437 }
5438 }
5439 }
5440 if (!IsUpdateExprFound) {
5441 // { v = x; x = expr; }
5442 auto *FirstExpr = dyn_cast<Expr>(First);
5443 auto *SecondExpr = dyn_cast<Expr>(Second);
5444 if (!FirstExpr || !SecondExpr ||
5445 !(FirstExpr->isInstantiationDependent() ||
5446 SecondExpr->isInstantiationDependent())) {
5447 auto *FirstBinOp = dyn_cast<BinaryOperator>(First);
5448 if (!FirstBinOp || FirstBinOp->getOpcode() != BO_Assign) {
5449 ErrorFound = NotAnAssignmentOp;
5450 NoteLoc = ErrorLoc = FirstBinOp ? FirstBinOp->getOperatorLoc()
5451 : First->getLocStart();
5452 NoteRange = ErrorRange = FirstBinOp
5453 ? FirstBinOp->getSourceRange()
5454 : SourceRange(ErrorLoc, ErrorLoc);
5455 } else {
5456 auto *SecondBinOp = dyn_cast<BinaryOperator>(Second);
5457 if (!SecondBinOp || SecondBinOp->getOpcode() != BO_Assign) {
5458 ErrorFound = NotAnAssignmentOp;
5459 NoteLoc = ErrorLoc = SecondBinOp
5460 ? SecondBinOp->getOperatorLoc()
5461 : Second->getLocStart();
5462 NoteRange = ErrorRange =
5463 SecondBinOp ? SecondBinOp->getSourceRange()
5464 : SourceRange(ErrorLoc, ErrorLoc);
5465 } else {
5466 auto *PossibleXRHSInFirst =
5467 FirstBinOp->getRHS()->IgnoreParenImpCasts();
5468 auto *PossibleXLHSInSecond =
5469 SecondBinOp->getLHS()->IgnoreParenImpCasts();
5470 llvm::FoldingSetNodeID X1Id, X2Id;
5471 PossibleXRHSInFirst->Profile(X1Id, Context,
5472 /*Canonical=*/true);
5473 PossibleXLHSInSecond->Profile(X2Id, Context,
5474 /*Canonical=*/true);
5475 IsUpdateExprFound = X1Id == X2Id;
5476 if (IsUpdateExprFound) {
5477 V = FirstBinOp->getLHS();
5478 X = SecondBinOp->getLHS();
5479 E = SecondBinOp->getRHS();
5480 UE = nullptr;
5481 IsXLHSInRHSPart = false;
5482 IsPostfixUpdate = true;
5483 } else {
5484 ErrorFound = NotASpecificExpression;
5485 ErrorLoc = FirstBinOp->getExprLoc();
5486 ErrorRange = FirstBinOp->getSourceRange();
5487 NoteLoc = SecondBinOp->getLHS()->getExprLoc();
5488 NoteRange = SecondBinOp->getRHS()->getSourceRange();
5489 }
5490 }
5491 }
5492 }
5493 }
5494 } else {
5495 NoteLoc = ErrorLoc = Body->getLocStart();
5496 NoteRange = ErrorRange =
5497 SourceRange(Body->getLocStart(), Body->getLocStart());
5498 ErrorFound = NotTwoSubstatements;
5499 }
5500 } else {
5501 NoteLoc = ErrorLoc = Body->getLocStart();
5502 NoteRange = ErrorRange =
5503 SourceRange(Body->getLocStart(), Body->getLocStart());
5504 ErrorFound = NotACompoundStatement;
5505 }
5506 if (ErrorFound != NoError) {
5507 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement)
5508 << ErrorRange;
5509 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
5510 return StmtError();
5511 } else if (CurContext->isDependentContext()) {
5512 UE = V = E = X = nullptr;
5513 }
5514 }
5515 }
5516
5517 getCurFunction()->setHasBranchProtectedScope();
5518
5519 return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
5520 X, V, E, UE, IsXLHSInRHSPart,
5521 IsPostfixUpdate);
5522}
5523
5524StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
5525 Stmt *AStmt,
5526 SourceLocation StartLoc,
5527 SourceLocation EndLoc) {
5528 if (!AStmt)
5529 return StmtError();
5530
5531 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5532 // 1.2.2 OpenMP Language Terminology
5533 // Structured block - An executable statement with a single entry at the
5534 // top and a single exit at the bottom.
5535 // The point of exit cannot be a branch out of the structured block.
5536 // longjmp() and throw() must not violate the entry/exit criteria.
5537 CS->getCapturedDecl()->setNothrow();
5538
5539 // OpenMP [2.16, Nesting of Regions]
5540 // If specified, a teams construct must be contained within a target
5541 // construct. That target construct must contain no statements or directives
5542 // outside of the teams construct.
5543 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->hasInnerTeamsRegion()) {
5544 auto S = AStmt->IgnoreContainers(/*IgnoreCaptured*/ true);
5545 bool OMPTeamsFound = true;
5546 if (auto *CS = dyn_cast<CompoundStmt>(S)) {
5547 auto I = CS->body_begin();
5548 while (I != CS->body_end()) {
5549 auto *OED = dyn_cast<OMPExecutableDirective>(*I);
5550 if (!OED || !isOpenMPTeamsDirective(OED->getDirectiveKind())) {
5551 OMPTeamsFound = false;
5552 break;
5553 }
5554 ++I;
5555 }
5556 assert(I != CS->body_end() && "Not found statement")((I != CS->body_end() && "Not found statement") ? static_cast
<void> (0) : __assert_fail ("I != CS->body_end() && \"Not found statement\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5556, __PRETTY_FUNCTION__))
;
5557 S = *I;
5558 } else {
5559 auto *OED = dyn_cast<OMPExecutableDirective>(S);
5560 OMPTeamsFound = OED && isOpenMPTeamsDirective(OED->getDirectiveKind());
5561 }
5562 if (!OMPTeamsFound) {
5563 Diag(StartLoc, diag::err_omp_target_contains_not_only_teams);
5564 Diag(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getInnerTeamsRegionLoc(),
5565 diag::note_omp_nested_teams_construct_here);
5566 Diag(S->getLocStart(), diag::note_omp_nested_statement_here)
5567 << isa<OMPExecutableDirective>(S);
5568 return StmtError();
5569 }
5570 }
5571
5572 getCurFunction()->setHasBranchProtectedScope();
5573
5574 return OMPTargetDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5575}
5576
5577StmtResult
5578Sema::ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
5579 Stmt *AStmt, SourceLocation StartLoc,
5580 SourceLocation EndLoc) {
5581 if (!AStmt)
5582 return StmtError();
5583
5584 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5585 // 1.2.2 OpenMP Language Terminology
5586 // Structured block - An executable statement with a single entry at the
5587 // top and a single exit at the bottom.
5588 // The point of exit cannot be a branch out of the structured block.
5589 // longjmp() and throw() must not violate the entry/exit criteria.
5590 CS->getCapturedDecl()->setNothrow();
5591
5592 getCurFunction()->setHasBranchProtectedScope();
5593
5594 return OMPTargetParallelDirective::Create(Context, StartLoc, EndLoc, Clauses,
5595 AStmt);
5596}
5597
5598StmtResult Sema::ActOnOpenMPTargetParallelForDirective(
5599 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5600 SourceLocation EndLoc,
5601 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5602 if (!AStmt)
5603 return StmtError();
5604
5605 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5606 // 1.2.2 OpenMP Language Terminology
5607 // Structured block - An executable statement with a single entry at the
5608 // top and a single exit at the bottom.
5609 // The point of exit cannot be a branch out of the structured block.
5610 // longjmp() and throw() must not violate the entry/exit criteria.
5611 CS->getCapturedDecl()->setNothrow();
5612
5613 OMPLoopDirective::HelperExprs B;
5614 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5615 // define the nested loops number.
5616 unsigned NestedLoopCount =
5617 CheckOpenMPLoop(OMPD_target_parallel_for, getCollapseNumberExpr(Clauses),
5618 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
5619 VarsWithImplicitDSA, B);
5620 if (NestedLoopCount == 0)
5621 return StmtError();
5622
5623 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target parallel for loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target parallel for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5624, __PRETTY_FUNCTION__))
5624 "omp target parallel for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target parallel for loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target parallel for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5624, __PRETTY_FUNCTION__))
;
5625
5626 if (!CurContext->isDependentContext()) {
5627 // Finalize the clauses that need pre-built expressions for CodeGen.
5628 for (auto C : Clauses) {
5629 if (auto *LC = dyn_cast<OMPLinearClause>(C))
5630 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5631 B.NumIterations, *this, CurScope,
5632 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
5633 return StmtError();
5634 }
5635 }
5636
5637 getCurFunction()->setHasBranchProtectedScope();
5638 return OMPTargetParallelForDirective::Create(Context, StartLoc, EndLoc,
5639 NestedLoopCount, Clauses, AStmt,
5640 B, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isCancelRegion());
5641}
5642
5643/// \brief Check for existence of a map clause in the list of clauses.
5644static bool HasMapClause(ArrayRef<OMPClause *> Clauses) {
5645 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
5646 I != E; ++I) {
5647 if (*I != nullptr && (*I)->getClauseKind() == OMPC_map) {
5648 return true;
5649 }
5650 }
5651
5652 return false;
5653}
5654
5655StmtResult Sema::ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
5656 Stmt *AStmt,
5657 SourceLocation StartLoc,
5658 SourceLocation EndLoc) {
5659 if (!AStmt)
5660 return StmtError();
5661
5662 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5662, __PRETTY_FUNCTION__))
;
5663
5664 // OpenMP [2.10.1, Restrictions, p. 97]
5665 // At least one map clause must appear on the directive.
5666 if (!HasMapClause(Clauses)) {
5667 Diag(StartLoc, diag::err_omp_no_map_for_directive)
5668 << getOpenMPDirectiveName(OMPD_target_data);
5669 return StmtError();
5670 }
5671
5672 getCurFunction()->setHasBranchProtectedScope();
5673
5674 return OMPTargetDataDirective::Create(Context, StartLoc, EndLoc, Clauses,
5675 AStmt);
5676}
5677
5678StmtResult
5679Sema::ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
5680 SourceLocation StartLoc,
5681 SourceLocation EndLoc) {
5682 // OpenMP [2.10.2, Restrictions, p. 99]
5683 // At least one map clause must appear on the directive.
5684 if (!HasMapClause(Clauses)) {
5685 Diag(StartLoc, diag::err_omp_no_map_for_directive)
5686 << getOpenMPDirectiveName(OMPD_target_enter_data);
5687 return StmtError();
5688 }
5689
5690 return OMPTargetEnterDataDirective::Create(Context, StartLoc, EndLoc,
5691 Clauses);
5692}
5693
5694StmtResult
5695Sema::ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
5696 SourceLocation StartLoc,
5697 SourceLocation EndLoc) {
5698 // OpenMP [2.10.3, Restrictions, p. 102]
5699 // At least one map clause must appear on the directive.
5700 if (!HasMapClause(Clauses)) {
5701 Diag(StartLoc, diag::err_omp_no_map_for_directive)
5702 << getOpenMPDirectiveName(OMPD_target_exit_data);
5703 return StmtError();
5704 }
5705
5706 return OMPTargetExitDataDirective::Create(Context, StartLoc, EndLoc, Clauses);
5707}
5708
5709StmtResult Sema::ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
5710 SourceLocation StartLoc,
5711 SourceLocation EndLoc) {
5712 bool seenMotionClause = false;
5713 for (auto *C : Clauses) {
5714 if (C->getClauseKind() == OMPC_to || C->getClauseKind() == OMPC_from)
5715 seenMotionClause = true;
5716 }
5717 if (!seenMotionClause) {
5718 Diag(StartLoc, diag::err_omp_at_least_one_motion_clause_required);
5719 return StmtError();
5720 }
5721 return OMPTargetUpdateDirective::Create(Context, StartLoc, EndLoc, Clauses);
5722}
5723
5724StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
5725 Stmt *AStmt, SourceLocation StartLoc,
5726 SourceLocation EndLoc) {
5727 if (!AStmt)
5728 return StmtError();
5729
5730 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5731 // 1.2.2 OpenMP Language Terminology
5732 // Structured block - An executable statement with a single entry at the
5733 // top and a single exit at the bottom.
5734 // The point of exit cannot be a branch out of the structured block.
5735 // longjmp() and throw() must not violate the entry/exit criteria.
5736 CS->getCapturedDecl()->setNothrow();
5737
5738 getCurFunction()->setHasBranchProtectedScope();
5739
5740 return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
5741}
5742
5743StmtResult
5744Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
5745 SourceLocation EndLoc,
5746 OpenMPDirectiveKind CancelRegion) {
5747 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
5748 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
5749 Diag(StartLoc, diag::err_omp_wrong_cancel_region)
5750 << getOpenMPDirectiveName(CancelRegion);
5751 return StmtError();
5752 }
5753 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isParentNowaitRegion()) {
5754 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0;
5755 return StmtError();
5756 }
5757 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isParentOrderedRegion()) {
5758 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0;
5759 return StmtError();
5760 }
5761 return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc,
5762 CancelRegion);
5763}
5764
5765StmtResult Sema::ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
5766 SourceLocation StartLoc,
5767 SourceLocation EndLoc,
5768 OpenMPDirectiveKind CancelRegion) {
5769 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for &&
5770 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) {
5771 Diag(StartLoc, diag::err_omp_wrong_cancel_region)
5772 << getOpenMPDirectiveName(CancelRegion);
5773 return StmtError();
5774 }
5775 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isParentNowaitRegion()) {
5776 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1;
5777 return StmtError();
5778 }
5779 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->isParentOrderedRegion()) {
5780 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1;
5781 return StmtError();
5782 }
5783 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setParentCancelRegion(/*Cancel=*/true);
5784 return OMPCancelDirective::Create(Context, StartLoc, EndLoc, Clauses,
5785 CancelRegion);
5786}
5787
5788static bool checkGrainsizeNumTasksClauses(Sema &S,
5789 ArrayRef<OMPClause *> Clauses) {
5790 OMPClause *PrevClause = nullptr;
5791 bool ErrorFound = false;
5792 for (auto *C : Clauses) {
5793 if (C->getClauseKind() == OMPC_grainsize ||
5794 C->getClauseKind() == OMPC_num_tasks) {
5795 if (!PrevClause)
5796 PrevClause = C;
5797 else if (PrevClause->getClauseKind() != C->getClauseKind()) {
5798 S.Diag(C->getLocStart(),
5799 diag::err_omp_grainsize_num_tasks_mutually_exclusive)
5800 << getOpenMPClauseName(C->getClauseKind())
5801 << getOpenMPClauseName(PrevClause->getClauseKind());
5802 S.Diag(PrevClause->getLocStart(),
5803 diag::note_omp_previous_grainsize_num_tasks)
5804 << getOpenMPClauseName(PrevClause->getClauseKind());
5805 ErrorFound = true;
5806 }
5807 }
5808 }
5809 return ErrorFound;
5810}
5811
5812StmtResult Sema::ActOnOpenMPTaskLoopDirective(
5813 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5814 SourceLocation EndLoc,
5815 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5816 if (!AStmt)
5817 return StmtError();
5818
5819 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5819, __PRETTY_FUNCTION__))
;
5820 OMPLoopDirective::HelperExprs B;
5821 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5822 // define the nested loops number.
5823 unsigned NestedLoopCount =
5824 CheckOpenMPLoop(OMPD_taskloop, getCollapseNumberExpr(Clauses),
5825 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
5826 VarsWithImplicitDSA, B);
5827 if (NestedLoopCount == 0)
5828 return StmtError();
5829
5830 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5831, __PRETTY_FUNCTION__))
5831 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5831, __PRETTY_FUNCTION__))
;
5832
5833 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
5834 // The grainsize clause and num_tasks clause are mutually exclusive and may
5835 // not appear on the same taskloop directive.
5836 if (checkGrainsizeNumTasksClauses(*this, Clauses))
5837 return StmtError();
5838
5839 getCurFunction()->setHasBranchProtectedScope();
5840 return OMPTaskLoopDirective::Create(Context, StartLoc, EndLoc,
5841 NestedLoopCount, Clauses, AStmt, B);
5842}
5843
5844StmtResult Sema::ActOnOpenMPTaskLoopSimdDirective(
5845 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5846 SourceLocation EndLoc,
5847 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5848 if (!AStmt)
5849 return StmtError();
5850
5851 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5851, __PRETTY_FUNCTION__))
;
5852 OMPLoopDirective::HelperExprs B;
5853 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
5854 // define the nested loops number.
5855 unsigned NestedLoopCount =
5856 CheckOpenMPLoop(OMPD_taskloop_simd, getCollapseNumberExpr(Clauses),
5857 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
5858 VarsWithImplicitDSA, B);
5859 if (NestedLoopCount == 0)
5860 return StmtError();
5861
5862 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5863, __PRETTY_FUNCTION__))
5863 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5863, __PRETTY_FUNCTION__))
;
5864
5865 if (!CurContext->isDependentContext()) {
5866 // Finalize the clauses that need pre-built expressions for CodeGen.
5867 for (auto C : Clauses) {
5868 if (auto *LC = dyn_cast<OMPLinearClause>(C))
5869 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
5870 B.NumIterations, *this, CurScope,
5871 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
5872 return StmtError();
5873 }
5874 }
5875
5876 // OpenMP, [2.9.2 taskloop Construct, Restrictions]
5877 // The grainsize clause and num_tasks clause are mutually exclusive and may
5878 // not appear on the same taskloop directive.
5879 if (checkGrainsizeNumTasksClauses(*this, Clauses))
5880 return StmtError();
5881
5882 getCurFunction()->setHasBranchProtectedScope();
5883 return OMPTaskLoopSimdDirective::Create(Context, StartLoc, EndLoc,
5884 NestedLoopCount, Clauses, AStmt, B);
5885}
5886
5887StmtResult Sema::ActOnOpenMPDistributeDirective(
5888 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5889 SourceLocation EndLoc,
5890 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5891 if (!AStmt)
5892 return StmtError();
5893
5894 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((isa<CapturedStmt>(AStmt) && "Captured statement expected"
) ? static_cast<void> (0) : __assert_fail ("isa<CapturedStmt>(AStmt) && \"Captured statement expected\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5894, __PRETTY_FUNCTION__))
;
5895 OMPLoopDirective::HelperExprs B;
5896 // In presence of clause 'collapse' with number of loops, it will
5897 // define the nested loops number.
5898 unsigned NestedLoopCount =
5899 CheckOpenMPLoop(OMPD_distribute, getCollapseNumberExpr(Clauses),
5900 nullptr /*ordered not a clause on distribute*/, AStmt,
5901 *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, VarsWithImplicitDSA, B);
5902 if (NestedLoopCount == 0)
5903 return StmtError();
5904
5905 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5906, __PRETTY_FUNCTION__))
5906 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5906, __PRETTY_FUNCTION__))
;
5907
5908 getCurFunction()->setHasBranchProtectedScope();
5909 return OMPDistributeDirective::Create(Context, StartLoc, EndLoc,
5910 NestedLoopCount, Clauses, AStmt, B);
5911}
5912
5913StmtResult Sema::ActOnOpenMPDistributeParallelForDirective(
5914 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5915 SourceLocation EndLoc,
5916 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5917 if (!AStmt)
5918 return StmtError();
5919
5920 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5921 // 1.2.2 OpenMP Language Terminology
5922 // Structured block - An executable statement with a single entry at the
5923 // top and a single exit at the bottom.
5924 // The point of exit cannot be a branch out of the structured block.
5925 // longjmp() and throw() must not violate the entry/exit criteria.
5926 CS->getCapturedDecl()->setNothrow();
5927
5928 OMPLoopDirective::HelperExprs B;
5929 // In presence of clause 'collapse' with number of loops, it will
5930 // define the nested loops number.
5931 unsigned NestedLoopCount = CheckOpenMPLoop(
5932 OMPD_distribute_parallel_for, getCollapseNumberExpr(Clauses),
5933 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
5934 VarsWithImplicitDSA, B);
5935 if (NestedLoopCount == 0)
5936 return StmtError();
5937
5938 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5939, __PRETTY_FUNCTION__))
5939 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5939, __PRETTY_FUNCTION__))
;
5940
5941 getCurFunction()->setHasBranchProtectedScope();
5942 return OMPDistributeParallelForDirective::Create(
5943 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
5944}
5945
5946StmtResult Sema::ActOnOpenMPDistributeParallelForSimdDirective(
5947 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5948 SourceLocation EndLoc,
5949 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5950 if (!AStmt)
5951 return StmtError();
5952
5953 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5954 // 1.2.2 OpenMP Language Terminology
5955 // Structured block - An executable statement with a single entry at the
5956 // top and a single exit at the bottom.
5957 // The point of exit cannot be a branch out of the structured block.
5958 // longjmp() and throw() must not violate the entry/exit criteria.
5959 CS->getCapturedDecl()->setNothrow();
5960
5961 OMPLoopDirective::HelperExprs B;
5962 // In presence of clause 'collapse' with number of loops, it will
5963 // define the nested loops number.
5964 unsigned NestedLoopCount = CheckOpenMPLoop(
5965 OMPD_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
5966 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
5967 VarsWithImplicitDSA, B);
5968 if (NestedLoopCount == 0)
5969 return StmtError();
5970
5971 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5972, __PRETTY_FUNCTION__))
5972 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 5972, __PRETTY_FUNCTION__))
;
5973
5974 if (checkSimdlenSafelenSpecified(*this, Clauses))
5975 return StmtError();
5976
5977 getCurFunction()->setHasBranchProtectedScope();
5978 return OMPDistributeParallelForSimdDirective::Create(
5979 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
5980}
5981
5982StmtResult Sema::ActOnOpenMPDistributeSimdDirective(
5983 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
5984 SourceLocation EndLoc,
5985 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
5986 if (!AStmt)
5987 return StmtError();
5988
5989 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
5990 // 1.2.2 OpenMP Language Terminology
5991 // Structured block - An executable statement with a single entry at the
5992 // top and a single exit at the bottom.
5993 // The point of exit cannot be a branch out of the structured block.
5994 // longjmp() and throw() must not violate the entry/exit criteria.
5995 CS->getCapturedDecl()->setNothrow();
5996
5997 OMPLoopDirective::HelperExprs B;
5998 // In presence of clause 'collapse' with number of loops, it will
5999 // define the nested loops number.
6000 unsigned NestedLoopCount =
6001 CheckOpenMPLoop(OMPD_distribute_simd, getCollapseNumberExpr(Clauses),
6002 nullptr /*ordered not a clause on distribute*/, AStmt,
6003 *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, VarsWithImplicitDSA, B);
6004 if (NestedLoopCount == 0)
6005 return StmtError();
6006
6007 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6008, __PRETTY_FUNCTION__))
6008 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6008, __PRETTY_FUNCTION__))
;
6009
6010 if (checkSimdlenSafelenSpecified(*this, Clauses))
6011 return StmtError();
6012
6013 getCurFunction()->setHasBranchProtectedScope();
6014 return OMPDistributeSimdDirective::Create(Context, StartLoc, EndLoc,
6015 NestedLoopCount, Clauses, AStmt, B);
6016}
6017
6018StmtResult Sema::ActOnOpenMPTargetParallelForSimdDirective(
6019 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6020 SourceLocation EndLoc,
6021 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6022 if (!AStmt)
6023 return StmtError();
6024
6025 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6026 // 1.2.2 OpenMP Language Terminology
6027 // Structured block - An executable statement with a single entry at the
6028 // top and a single exit at the bottom.
6029 // The point of exit cannot be a branch out of the structured block.
6030 // longjmp() and throw() must not violate the entry/exit criteria.
6031 CS->getCapturedDecl()->setNothrow();
6032
6033 OMPLoopDirective::HelperExprs B;
6034 // In presence of clause 'collapse' or 'ordered' with number of loops, it will
6035 // define the nested loops number.
6036 unsigned NestedLoopCount = CheckOpenMPLoop(
6037 OMPD_target_parallel_for_simd, getCollapseNumberExpr(Clauses),
6038 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6039 VarsWithImplicitDSA, B);
6040 if (NestedLoopCount == 0)
6041 return StmtError();
6042
6043 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target parallel for simd loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target parallel for simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6044, __PRETTY_FUNCTION__))
6044 "omp target parallel for simd loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target parallel for simd loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target parallel for simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6044, __PRETTY_FUNCTION__))
;
6045
6046 if (!CurContext->isDependentContext()) {
6047 // Finalize the clauses that need pre-built expressions for CodeGen.
6048 for (auto C : Clauses) {
6049 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6050 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6051 B.NumIterations, *this, CurScope,
6052 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6053 return StmtError();
6054 }
6055 }
6056 if (checkSimdlenSafelenSpecified(*this, Clauses))
6057 return StmtError();
6058
6059 getCurFunction()->setHasBranchProtectedScope();
6060 return OMPTargetParallelForSimdDirective::Create(
6061 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6062}
6063
6064StmtResult Sema::ActOnOpenMPTargetSimdDirective(
6065 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6066 SourceLocation EndLoc,
6067 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6068 if (!AStmt)
6069 return StmtError();
6070
6071 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6072 // 1.2.2 OpenMP Language Terminology
6073 // Structured block - An executable statement with a single entry at the
6074 // top and a single exit at the bottom.
6075 // The point of exit cannot be a branch out of the structured block.
6076 // longjmp() and throw() must not violate the entry/exit criteria.
6077 CS->getCapturedDecl()->setNothrow();
6078
6079 OMPLoopDirective::HelperExprs B;
6080 // In presence of clause 'collapse' with number of loops, it will define the
6081 // nested loops number.
6082 unsigned NestedLoopCount =
6083 CheckOpenMPLoop(OMPD_target_simd, getCollapseNumberExpr(Clauses),
6084 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6085 VarsWithImplicitDSA, B);
6086 if (NestedLoopCount == 0)
6087 return StmtError();
6088
6089 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target simd loop exprs were not built") ? static_cast<
void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6090, __PRETTY_FUNCTION__))
6090 "omp target simd loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target simd loop exprs were not built") ? static_cast<
void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6090, __PRETTY_FUNCTION__))
;
6091
6092 if (!CurContext->isDependentContext()) {
6093 // Finalize the clauses that need pre-built expressions for CodeGen.
6094 for (auto C : Clauses) {
6095 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6096 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6097 B.NumIterations, *this, CurScope,
6098 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6099 return StmtError();
6100 }
6101 }
6102
6103 if (checkSimdlenSafelenSpecified(*this, Clauses))
6104 return StmtError();
6105
6106 getCurFunction()->setHasBranchProtectedScope();
6107 return OMPTargetSimdDirective::Create(Context, StartLoc, EndLoc,
6108 NestedLoopCount, Clauses, AStmt, B);
6109}
6110
6111StmtResult Sema::ActOnOpenMPTeamsDistributeDirective(
6112 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6113 SourceLocation EndLoc,
6114 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6115 if (!AStmt)
6116 return StmtError();
6117
6118 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6119 // 1.2.2 OpenMP Language Terminology
6120 // Structured block - An executable statement with a single entry at the
6121 // top and a single exit at the bottom.
6122 // The point of exit cannot be a branch out of the structured block.
6123 // longjmp() and throw() must not violate the entry/exit criteria.
6124 CS->getCapturedDecl()->setNothrow();
6125
6126 OMPLoopDirective::HelperExprs B;
6127 // In presence of clause 'collapse' with number of loops, it will
6128 // define the nested loops number.
6129 unsigned NestedLoopCount =
6130 CheckOpenMPLoop(OMPD_teams_distribute, getCollapseNumberExpr(Clauses),
6131 nullptr /*ordered not a clause on distribute*/, AStmt,
6132 *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, VarsWithImplicitDSA, B);
6133 if (NestedLoopCount == 0)
6134 return StmtError();
6135
6136 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp teams distribute loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp teams distribute loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6137, __PRETTY_FUNCTION__))
6137 "omp teams distribute loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp teams distribute loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp teams distribute loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6137, __PRETTY_FUNCTION__))
;
6138
6139 getCurFunction()->setHasBranchProtectedScope();
6140 return OMPTeamsDistributeDirective::Create(
6141 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6142}
6143
6144StmtResult Sema::ActOnOpenMPTeamsDistributeSimdDirective(
6145 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6146 SourceLocation EndLoc,
6147 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6148 if (!AStmt)
6149 return StmtError();
6150
6151 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6152 // 1.2.2 OpenMP Language Terminology
6153 // Structured block - An executable statement with a single entry at the
6154 // top and a single exit at the bottom.
6155 // The point of exit cannot be a branch out of the structured block.
6156 // longjmp() and throw() must not violate the entry/exit criteria.
6157 CS->getCapturedDecl()->setNothrow();
6158
6159 OMPLoopDirective::HelperExprs B;
6160 // In presence of clause 'collapse' with number of loops, it will
6161 // define the nested loops number.
6162 unsigned NestedLoopCount = CheckOpenMPLoop(
6163 OMPD_teams_distribute_simd, getCollapseNumberExpr(Clauses),
6164 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6165 VarsWithImplicitDSA, B);
6166
6167 if (NestedLoopCount == 0)
6168 return StmtError();
6169
6170 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp teams distribute simd loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp teams distribute simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6171, __PRETTY_FUNCTION__))
6171 "omp teams distribute simd loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp teams distribute simd loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp teams distribute simd loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6171, __PRETTY_FUNCTION__))
;
6172
6173 if (!CurContext->isDependentContext()) {
6174 // Finalize the clauses that need pre-built expressions for CodeGen.
6175 for (auto C : Clauses) {
6176 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6177 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6178 B.NumIterations, *this, CurScope,
6179 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6180 return StmtError();
6181 }
6182 }
6183
6184 if (checkSimdlenSafelenSpecified(*this, Clauses))
6185 return StmtError();
6186
6187 getCurFunction()->setHasBranchProtectedScope();
6188 return OMPTeamsDistributeSimdDirective::Create(
6189 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6190}
6191
6192StmtResult Sema::ActOnOpenMPTeamsDistributeParallelForSimdDirective(
6193 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6194 SourceLocation EndLoc,
6195 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6196 if (!AStmt)
6197 return StmtError();
6198
6199 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6200 // 1.2.2 OpenMP Language Terminology
6201 // Structured block - An executable statement with a single entry at the
6202 // top and a single exit at the bottom.
6203 // The point of exit cannot be a branch out of the structured block.
6204 // longjmp() and throw() must not violate the entry/exit criteria.
6205 CS->getCapturedDecl()->setNothrow();
6206
6207 OMPLoopDirective::HelperExprs B;
6208 // In presence of clause 'collapse' with number of loops, it will
6209 // define the nested loops number.
6210 auto NestedLoopCount = CheckOpenMPLoop(
6211 OMPD_teams_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses),
6212 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6213 VarsWithImplicitDSA, B);
6214
6215 if (NestedLoopCount == 0)
6216 return StmtError();
6217
6218 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6219, __PRETTY_FUNCTION__))
6219 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6219, __PRETTY_FUNCTION__))
;
6220
6221 if (!CurContext->isDependentContext()) {
6222 // Finalize the clauses that need pre-built expressions for CodeGen.
6223 for (auto C : Clauses) {
6224 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6225 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6226 B.NumIterations, *this, CurScope,
6227 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6228 return StmtError();
6229 }
6230 }
6231
6232 if (checkSimdlenSafelenSpecified(*this, Clauses))
6233 return StmtError();
6234
6235 getCurFunction()->setHasBranchProtectedScope();
6236 return OMPTeamsDistributeParallelForSimdDirective::Create(
6237 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6238}
6239
6240StmtResult Sema::ActOnOpenMPTeamsDistributeParallelForDirective(
6241 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6242 SourceLocation EndLoc,
6243 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6244 if (!AStmt)
6245 return StmtError();
6246
6247 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6248 // 1.2.2 OpenMP Language Terminology
6249 // Structured block - An executable statement with a single entry at the
6250 // top and a single exit at the bottom.
6251 // The point of exit cannot be a branch out of the structured block.
6252 // longjmp() and throw() must not violate the entry/exit criteria.
6253 CS->getCapturedDecl()->setNothrow();
6254
6255 OMPLoopDirective::HelperExprs B;
6256 // In presence of clause 'collapse' with number of loops, it will
6257 // define the nested loops number.
6258 unsigned NestedLoopCount = CheckOpenMPLoop(
6259 OMPD_teams_distribute_parallel_for, getCollapseNumberExpr(Clauses),
6260 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6261 VarsWithImplicitDSA, B);
6262
6263 if (NestedLoopCount == 0)
6264 return StmtError();
6265
6266 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6267, __PRETTY_FUNCTION__))
6267 "omp for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp for loop exprs were not built") ? static_cast<void>
(0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6267, __PRETTY_FUNCTION__))
;
6268
6269 if (!CurContext->isDependentContext()) {
6270 // Finalize the clauses that need pre-built expressions for CodeGen.
6271 for (auto C : Clauses) {
6272 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6273 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6274 B.NumIterations, *this, CurScope,
6275 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6276 return StmtError();
6277 }
6278 }
6279
6280 getCurFunction()->setHasBranchProtectedScope();
6281 return OMPTeamsDistributeParallelForDirective::Create(
6282 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6283}
6284
6285StmtResult Sema::ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
6286 Stmt *AStmt,
6287 SourceLocation StartLoc,
6288 SourceLocation EndLoc) {
6289 if (!AStmt)
6290 return StmtError();
6291
6292 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6293 // 1.2.2 OpenMP Language Terminology
6294 // Structured block - An executable statement with a single entry at the
6295 // top and a single exit at the bottom.
6296 // The point of exit cannot be a branch out of the structured block.
6297 // longjmp() and throw() must not violate the entry/exit criteria.
6298 CS->getCapturedDecl()->setNothrow();
6299
6300 getCurFunction()->setHasBranchProtectedScope();
6301
6302 return OMPTargetTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses,
6303 AStmt);
6304}
6305
6306StmtResult Sema::ActOnOpenMPTargetTeamsDistributeDirective(
6307 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6308 SourceLocation EndLoc,
6309 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6310 if (!AStmt)
6311 return StmtError();
6312
6313 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6314 // 1.2.2 OpenMP Language Terminology
6315 // Structured block - An executable statement with a single entry at the
6316 // top and a single exit at the bottom.
6317 // The point of exit cannot be a branch out of the structured block.
6318 // longjmp() and throw() must not violate the entry/exit criteria.
6319 CS->getCapturedDecl()->setNothrow();
6320
6321 OMPLoopDirective::HelperExprs B;
6322 // In presence of clause 'collapse' with number of loops, it will
6323 // define the nested loops number.
6324 auto NestedLoopCount = CheckOpenMPLoop(
6325 OMPD_target_teams_distribute,
6326 getCollapseNumberExpr(Clauses),
6327 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6328 VarsWithImplicitDSA, B);
6329 if (NestedLoopCount == 0)
6330 return StmtError();
6331
6332 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6333, __PRETTY_FUNCTION__))
6333 "omp target teams distribute loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute loop exprs were not built") ? static_cast
<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6333, __PRETTY_FUNCTION__))
;
6334
6335 getCurFunction()->setHasBranchProtectedScope();
6336 return OMPTargetTeamsDistributeDirective::Create(
6337 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6338}
6339
6340StmtResult Sema::ActOnOpenMPTargetTeamsDistributeParallelForDirective(
6341 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6342 SourceLocation EndLoc,
6343 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6344 if (!AStmt)
6345 return StmtError();
6346
6347 CapturedStmt *CS = cast<CapturedStmt>(AStmt);
6348 // 1.2.2 OpenMP Language Terminology
6349 // Structured block - An executable statement with a single entry at the
6350 // top and a single exit at the bottom.
6351 // The point of exit cannot be a branch out of the structured block.
6352 // longjmp() and throw() must not violate the entry/exit criteria.
6353 CS->getCapturedDecl()->setNothrow();
6354
6355 OMPLoopDirective::HelperExprs B;
6356 // In presence of clause 'collapse' with number of loops, it will
6357 // define the nested loops number.
6358 auto NestedLoopCount = CheckOpenMPLoop(
6359 OMPD_target_teams_distribute_parallel_for,
6360 getCollapseNumberExpr(Clauses),
6361 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6362 VarsWithImplicitDSA, B);
6363 if (NestedLoopCount == 0)
6364 return StmtError();
6365
6366 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute parallel for loop exprs were not built"
) ? static_cast<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute parallel for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6367, __PRETTY_FUNCTION__))
6367 "omp target teams distribute parallel for loop exprs were not built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute parallel for loop exprs were not built"
) ? static_cast<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute parallel for loop exprs were not built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6367, __PRETTY_FUNCTION__))
;
6368
6369 if (!CurContext->isDependentContext()) {
6370 // Finalize the clauses that need pre-built expressions for CodeGen.
6371 for (auto C : Clauses) {
6372 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6373 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6374 B.NumIterations, *this, CurScope,
6375 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6376 return StmtError();
6377 }
6378 }
6379
6380 getCurFunction()->setHasBranchProtectedScope();
6381 return OMPTargetTeamsDistributeParallelForDirective::Create(
6382 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6383}
6384
6385StmtResult Sema::ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
6386 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
6387 SourceLocation EndLoc,
6388 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) {
6389 if (!AStmt)
6390 return StmtError();
6391
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();
6399
6400 OMPLoopDirective::HelperExprs B;
6401 // In presence of clause 'collapse' with number of loops, it will
6402 // define the nested loops number.
6403 auto NestedLoopCount = CheckOpenMPLoop(
6404 OMPD_target_teams_distribute_parallel_for_simd,
6405 getCollapseNumberExpr(Clauses),
6406 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
,
6407 VarsWithImplicitDSA, B);
6408 if (NestedLoopCount == 0)
6409 return StmtError();
6410
6411 assert((CurContext->isDependentContext() || B.builtAll()) &&(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute parallel for simd loop exprs were not "
"built") ? static_cast<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute parallel for simd loop exprs were not \" \"built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6413, __PRETTY_FUNCTION__))
6412 "omp target teams distribute parallel for simd loop exprs were not "(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute parallel for simd loop exprs were not "
"built") ? static_cast<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute parallel for simd loop exprs were not \" \"built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6413, __PRETTY_FUNCTION__))
6413 "built")(((CurContext->isDependentContext() || B.builtAll()) &&
"omp target teams distribute parallel for simd loop exprs were not "
"built") ? static_cast<void> (0) : __assert_fail ("(CurContext->isDependentContext() || B.builtAll()) && \"omp target teams distribute parallel for simd loop exprs were not \" \"built\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6413, __PRETTY_FUNCTION__))
;
6414
6415 if (!CurContext->isDependentContext()) {
6416 // Finalize the clauses that need pre-built expressions for CodeGen.
6417 for (auto C : Clauses) {
6418 if (auto *LC = dyn_cast<OMPLinearClause>(C))
6419 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
6420 B.NumIterations, *this, CurScope,
6421 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
))
6422 return StmtError();
6423 }
6424 }
6425
6426 getCurFunction()->setHasBranchProtectedScope();
6427 return OMPTargetTeamsDistributeParallelForSimdDirective::Create(
6428 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
6429}
6430
6431OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
6432 SourceLocation StartLoc,
6433 SourceLocation LParenLoc,
6434 SourceLocation EndLoc) {
6435 OMPClause *Res = nullptr;
6436 switch (Kind) {
6437 case OMPC_final:
6438 Res = ActOnOpenMPFinalClause(Expr, StartLoc, LParenLoc, EndLoc);
6439 break;
6440 case OMPC_num_threads:
6441 Res = ActOnOpenMPNumThreadsClause(Expr, StartLoc, LParenLoc, EndLoc);
6442 break;
6443 case OMPC_safelen:
6444 Res = ActOnOpenMPSafelenClause(Expr, StartLoc, LParenLoc, EndLoc);
6445 break;
6446 case OMPC_simdlen:
6447 Res = ActOnOpenMPSimdlenClause(Expr, StartLoc, LParenLoc, EndLoc);
6448 break;
6449 case OMPC_collapse:
6450 Res = ActOnOpenMPCollapseClause(Expr, StartLoc, LParenLoc, EndLoc);
6451 break;
6452 case OMPC_ordered:
6453 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Expr);
6454 break;
6455 case OMPC_device:
6456 Res = ActOnOpenMPDeviceClause(Expr, StartLoc, LParenLoc, EndLoc);
6457 break;
6458 case OMPC_num_teams:
6459 Res = ActOnOpenMPNumTeamsClause(Expr, StartLoc, LParenLoc, EndLoc);
6460 break;
6461 case OMPC_thread_limit:
6462 Res = ActOnOpenMPThreadLimitClause(Expr, StartLoc, LParenLoc, EndLoc);
6463 break;
6464 case OMPC_priority:
6465 Res = ActOnOpenMPPriorityClause(Expr, StartLoc, LParenLoc, EndLoc);
6466 break;
6467 case OMPC_grainsize:
6468 Res = ActOnOpenMPGrainsizeClause(Expr, StartLoc, LParenLoc, EndLoc);
6469 break;
6470 case OMPC_num_tasks:
6471 Res = ActOnOpenMPNumTasksClause(Expr, StartLoc, LParenLoc, EndLoc);
6472 break;
6473 case OMPC_hint:
6474 Res = ActOnOpenMPHintClause(Expr, StartLoc, LParenLoc, EndLoc);
6475 break;
6476 case OMPC_if:
6477 case OMPC_default:
6478 case OMPC_proc_bind:
6479 case OMPC_schedule:
6480 case OMPC_private:
6481 case OMPC_firstprivate:
6482 case OMPC_lastprivate:
6483 case OMPC_shared:
6484 case OMPC_reduction:
6485 case OMPC_linear:
6486 case OMPC_aligned:
6487 case OMPC_copyin:
6488 case OMPC_copyprivate:
6489 case OMPC_nowait:
6490 case OMPC_untied:
6491 case OMPC_mergeable:
6492 case OMPC_threadprivate:
6493 case OMPC_flush:
6494 case OMPC_read:
6495 case OMPC_write:
6496 case OMPC_update:
6497 case OMPC_capture:
6498 case OMPC_seq_cst:
6499 case OMPC_depend:
6500 case OMPC_threads:
6501 case OMPC_simd:
6502 case OMPC_map:
6503 case OMPC_nogroup:
6504 case OMPC_dist_schedule:
6505 case OMPC_defaultmap:
6506 case OMPC_unknown:
6507 case OMPC_uniform:
6508 case OMPC_to:
6509 case OMPC_from:
6510 case OMPC_use_device_ptr:
6511 case OMPC_is_device_ptr:
6512 llvm_unreachable("Clause is not allowed.")::llvm::llvm_unreachable_internal("Clause is not allowed.", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6512)
;
6513 }
6514 return Res;
6515}
6516
6517OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
6518 Expr *Condition, SourceLocation StartLoc,
6519 SourceLocation LParenLoc,
6520 SourceLocation NameModifierLoc,
6521 SourceLocation ColonLoc,
6522 SourceLocation EndLoc) {
6523 Expr *ValExpr = Condition;
6524 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
6525 !Condition->isInstantiationDependent() &&
6526 !Condition->containsUnexpandedParameterPack()) {
6527 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
6528 if (Val.isInvalid())
6529 return nullptr;
6530
6531 ValExpr = MakeFullExpr(Val.get()).get();
6532 }
6533
6534 return new (Context) OMPIfClause(NameModifier, ValExpr, StartLoc, LParenLoc,
6535 NameModifierLoc, ColonLoc, EndLoc);
6536}
6537
6538OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition,
6539 SourceLocation StartLoc,
6540 SourceLocation LParenLoc,
6541 SourceLocation EndLoc) {
6542 Expr *ValExpr = Condition;
6543 if (!Condition->isValueDependent() && !Condition->isTypeDependent() &&
6544 !Condition->isInstantiationDependent() &&
6545 !Condition->containsUnexpandedParameterPack()) {
6546 ExprResult Val = CheckBooleanCondition(StartLoc, Condition);
6547 if (Val.isInvalid())
6548 return nullptr;
6549
6550 ValExpr = MakeFullExpr(Val.get()).get();
6551 }
6552
6553 return new (Context) OMPFinalClause(ValExpr, StartLoc, LParenLoc, EndLoc);
6554}
6555ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc,
6556 Expr *Op) {
6557 if (!Op)
6558 return ExprError();
6559
6560 class IntConvertDiagnoser : public ICEConvertDiagnoser {
6561 public:
6562 IntConvertDiagnoser()
6563 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false, false, true) {}
6564 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
6565 QualType T) override {
6566 return S.Diag(Loc, diag::err_omp_not_integral) << T;
6567 }
6568 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
6569 QualType T) override {
6570 return S.Diag(Loc, diag::err_omp_incomplete_type) << T;
6571 }
6572 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
6573 QualType T,
6574 QualType ConvTy) override {
6575 return S.Diag(Loc, diag::err_omp_explicit_conversion) << T << ConvTy;
6576 }
6577 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
6578 QualType ConvTy) override {
6579 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
6580 << ConvTy->isEnumeralType() << ConvTy;
6581 }
6582 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
6583 QualType T) override {
6584 return S.Diag(Loc, diag::err_omp_ambiguous_conversion) << T;
6585 }
6586 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
6587 QualType ConvTy) override {
6588 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here)
6589 << ConvTy->isEnumeralType() << ConvTy;
6590 }
6591 SemaDiagnosticBuilder diagnoseConversion(Sema &, SourceLocation, QualType,
6592 QualType) override {
6593 llvm_unreachable("conversion functions are permitted")::llvm::llvm_unreachable_internal("conversion functions are permitted"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6593)
;
6594 }
6595 } ConvertDiagnoser;
6596 return PerformContextualImplicitConversion(Loc, Op, ConvertDiagnoser);
6597}
6598
6599static bool IsNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef,
6600 OpenMPClauseKind CKind,
6601 bool StrictlyPositive) {
6602 if (!ValExpr->isTypeDependent() && !ValExpr->isValueDependent() &&
6603 !ValExpr->isInstantiationDependent()) {
6604 SourceLocation Loc = ValExpr->getExprLoc();
6605 ExprResult Value =
6606 SemaRef.PerformOpenMPImplicitIntegerConversion(Loc, ValExpr);
6607 if (Value.isInvalid())
6608 return false;
6609
6610 ValExpr = Value.get();
6611 // The expression must evaluate to a non-negative integer value.
6612 llvm::APSInt Result;
6613 if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) &&
6614 Result.isSigned() &&
6615 !((!StrictlyPositive && Result.isNonNegative()) ||
6616 (StrictlyPositive && Result.isStrictlyPositive()))) {
6617 SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
6618 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
6619 << ValExpr->getSourceRange();
6620 return false;
6621 }
6622 }
6623 return true;
6624}
6625
6626OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads,
6627 SourceLocation StartLoc,
6628 SourceLocation LParenLoc,
6629 SourceLocation EndLoc) {
6630 Expr *ValExpr = NumThreads;
6631
6632 // OpenMP [2.5, Restrictions]
6633 // The num_threads expression must evaluate to a positive integer value.
6634 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_threads,
6635 /*StrictlyPositive=*/true))
6636 return nullptr;
6637
6638 return new (Context)
6639 OMPNumThreadsClause(ValExpr, StartLoc, LParenLoc, EndLoc);
6640}
6641
6642ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
6643 OpenMPClauseKind CKind,
6644 bool StrictlyPositive) {
6645 if (!E)
6646 return ExprError();
6647 if (E->isValueDependent() || E->isTypeDependent() ||
6648 E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
6649 return E;
6650 llvm::APSInt Result;
6651 ExprResult ICE = VerifyIntegerConstantExpression(E, &Result);
6652 if (ICE.isInvalid())
6653 return ExprError();
6654 if ((StrictlyPositive && !Result.isStrictlyPositive()) ||
6655 (!StrictlyPositive && !Result.isNonNegative())) {
6656 Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
6657 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
6658 << E->getSourceRange();
6659 return ExprError();
6660 }
6661 if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
6662 Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
6663 << E->getSourceRange();
6664 return ExprError();
6665 }
6666 if (CKind == OMPC_collapse && DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getAssociatedLoops() == 1)
6667 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setAssociatedLoops(Result.getExtValue());
6668 else if (CKind == OMPC_ordered)
6669 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setAssociatedLoops(Result.getExtValue());
6670 return ICE;
6671}
6672
6673OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
6674 SourceLocation LParenLoc,
6675 SourceLocation EndLoc) {
6676 // OpenMP [2.8.1, simd construct, Description]
6677 // The parameter of the safelen clause must be a constant
6678 // positive integer expression.
6679 ExprResult Safelen = VerifyPositiveIntegerConstantInClause(Len, OMPC_safelen);
6680 if (Safelen.isInvalid())
6681 return nullptr;
6682 return new (Context)
6683 OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc);
6684}
6685
6686OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
6687 SourceLocation LParenLoc,
6688 SourceLocation EndLoc) {
6689 // OpenMP [2.8.1, simd construct, Description]
6690 // The parameter of the simdlen clause must be a constant
6691 // positive integer expression.
6692 ExprResult Simdlen = VerifyPositiveIntegerConstantInClause(Len, OMPC_simdlen);
6693 if (Simdlen.isInvalid())
6694 return nullptr;
6695 return new (Context)
6696 OMPSimdlenClause(Simdlen.get(), StartLoc, LParenLoc, EndLoc);
6697}
6698
6699OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops,
6700 SourceLocation StartLoc,
6701 SourceLocation LParenLoc,
6702 SourceLocation EndLoc) {
6703 // OpenMP [2.7.1, loop construct, Description]
6704 // OpenMP [2.8.1, simd construct, Description]
6705 // OpenMP [2.9.6, distribute construct, Description]
6706 // The parameter of the collapse clause must be a constant
6707 // positive integer expression.
6708 ExprResult NumForLoopsResult =
6709 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_collapse);
6710 if (NumForLoopsResult.isInvalid())
6711 return nullptr;
6712 return new (Context)
6713 OMPCollapseClause(NumForLoopsResult.get(), StartLoc, LParenLoc, EndLoc);
6714}
6715
6716OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc,
6717 SourceLocation EndLoc,
6718 SourceLocation LParenLoc,
6719 Expr *NumForLoops) {
6720 // OpenMP [2.7.1, loop construct, Description]
6721 // OpenMP [2.8.1, simd construct, Description]
6722 // OpenMP [2.9.6, distribute construct, Description]
6723 // The parameter of the ordered clause must be a constant
6724 // positive integer expression if any.
6725 if (NumForLoops && LParenLoc.isValid()) {
6726 ExprResult NumForLoopsResult =
6727 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered);
6728 if (NumForLoopsResult.isInvalid())
6729 return nullptr;
6730 NumForLoops = NumForLoopsResult.get();
6731 } else
6732 NumForLoops = nullptr;
6733 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setOrderedRegion(/*IsOrdered=*/true, NumForLoops);
6734 return new (Context)
6735 OMPOrderedClause(NumForLoops, StartLoc, LParenLoc, EndLoc);
6736}
6737
6738OMPClause *Sema::ActOnOpenMPSimpleClause(
6739 OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc,
6740 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {
6741 OMPClause *Res = nullptr;
6742 switch (Kind) {
6743 case OMPC_default:
6744 Res =
6745 ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument),
6746 ArgumentLoc, StartLoc, LParenLoc, EndLoc);
6747 break;
6748 case OMPC_proc_bind:
6749 Res = ActOnOpenMPProcBindClause(
6750 static_cast<OpenMPProcBindClauseKind>(Argument), ArgumentLoc, StartLoc,
6751 LParenLoc, EndLoc);
6752 break;
6753 case OMPC_if:
6754 case OMPC_final:
6755 case OMPC_num_threads:
6756 case OMPC_safelen:
6757 case OMPC_simdlen:
6758 case OMPC_collapse:
6759 case OMPC_schedule:
6760 case OMPC_private:
6761 case OMPC_firstprivate:
6762 case OMPC_lastprivate:
6763 case OMPC_shared:
6764 case OMPC_reduction:
6765 case OMPC_linear:
6766 case OMPC_aligned:
6767 case OMPC_copyin:
6768 case OMPC_copyprivate:
6769 case OMPC_ordered:
6770 case OMPC_nowait:
6771 case OMPC_untied:
6772 case OMPC_mergeable:
6773 case OMPC_threadprivate:
6774 case OMPC_flush:
6775 case OMPC_read:
6776 case OMPC_write:
6777 case OMPC_update:
6778 case OMPC_capture:
6779 case OMPC_seq_cst:
6780 case OMPC_depend:
6781 case OMPC_device:
6782 case OMPC_threads:
6783 case OMPC_simd:
6784 case OMPC_map:
6785 case OMPC_num_teams:
6786 case OMPC_thread_limit:
6787 case OMPC_priority:
6788 case OMPC_grainsize:
6789 case OMPC_nogroup:
6790 case OMPC_num_tasks:
6791 case OMPC_hint:
6792 case OMPC_dist_schedule:
6793 case OMPC_defaultmap:
6794 case OMPC_unknown:
6795 case OMPC_uniform:
6796 case OMPC_to:
6797 case OMPC_from:
6798 case OMPC_use_device_ptr:
6799 case OMPC_is_device_ptr:
6800 llvm_unreachable("Clause is not allowed.")::llvm::llvm_unreachable_internal("Clause is not allowed.", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6800)
;
6801 }
6802 return Res;
6803}
6804
6805static std::string
6806getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last,
6807 ArrayRef<unsigned> Exclude = llvm::None) {
6808 std::string Values;
6809 unsigned Bound = Last >= 2 ? Last - 2 : 0;
6810 unsigned Skipped = Exclude.size();
6811 auto S = Exclude.begin(), E = Exclude.end();
6812 for (unsigned i = First; i < Last; ++i) {
6813 if (std::find(S, E, i) != E) {
6814 --Skipped;
6815 continue;
6816 }
6817 Values += "'";
6818 Values += getOpenMPSimpleClauseTypeName(K, i);
6819 Values += "'";
6820 if (i == Bound - Skipped)
6821 Values += " or ";
6822 else if (i != Bound + 1 - Skipped)
6823 Values += ", ";
6824 }
6825 return Values;
6826}
6827
6828OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
6829 SourceLocation KindKwLoc,
6830 SourceLocation StartLoc,
6831 SourceLocation LParenLoc,
6832 SourceLocation EndLoc) {
6833 if (Kind == OMPC_DEFAULT_unknown) {
6834 static_assert(OMPC_DEFAULT_unknown > 0,
6835 "OMPC_DEFAULT_unknown not greater than 0");
6836 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
6837 << getListOfPossibleValues(OMPC_default, /*First=*/0,
6838 /*Last=*/OMPC_DEFAULT_unknown)
6839 << getOpenMPClauseName(OMPC_default);
6840 return nullptr;
6841 }
6842 switch (Kind) {
6843 case OMPC_DEFAULT_none:
6844 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setDefaultDSANone(KindKwLoc);
6845 break;
6846 case OMPC_DEFAULT_shared:
6847 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setDefaultDSAShared(KindKwLoc);
6848 break;
6849 case OMPC_DEFAULT_unknown:
6850 llvm_unreachable("Clause kind is not allowed.")::llvm::llvm_unreachable_internal("Clause kind is not allowed."
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6850)
;
6851 break;
6852 }
6853 return new (Context)
6854 OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
6855}
6856
6857OMPClause *Sema::ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
6858 SourceLocation KindKwLoc,
6859 SourceLocation StartLoc,
6860 SourceLocation LParenLoc,
6861 SourceLocation EndLoc) {
6862 if (Kind == OMPC_PROC_BIND_unknown) {
6863 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
6864 << getListOfPossibleValues(OMPC_proc_bind, /*First=*/0,
6865 /*Last=*/OMPC_PROC_BIND_unknown)
6866 << getOpenMPClauseName(OMPC_proc_bind);
6867 return nullptr;
6868 }
6869 return new (Context)
6870 OMPProcBindClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
6871}
6872
6873OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
6874 OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
6875 SourceLocation StartLoc, SourceLocation LParenLoc,
6876 ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc,
6877 SourceLocation EndLoc) {
6878 OMPClause *Res = nullptr;
6879 switch (Kind) {
6880 case OMPC_schedule:
6881 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
6882 assert(Argument.size() == NumberOfElements &&((Argument.size() == NumberOfElements && ArgumentLoc.
size() == NumberOfElements) ? static_cast<void> (0) : __assert_fail
("Argument.size() == NumberOfElements && ArgumentLoc.size() == NumberOfElements"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6883, __PRETTY_FUNCTION__))
6883 ArgumentLoc.size() == NumberOfElements)((Argument.size() == NumberOfElements && ArgumentLoc.
size() == NumberOfElements) ? static_cast<void> (0) : __assert_fail
("Argument.size() == NumberOfElements && ArgumentLoc.size() == NumberOfElements"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6883, __PRETTY_FUNCTION__))
;
6884 Res = ActOnOpenMPScheduleClause(
6885 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier1]),
6886 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier2]),
6887 static_cast<OpenMPScheduleClauseKind>(Argument[ScheduleKind]), Expr,
6888 StartLoc, LParenLoc, ArgumentLoc[Modifier1], ArgumentLoc[Modifier2],
6889 ArgumentLoc[ScheduleKind], DelimLoc, EndLoc);
6890 break;
6891 case OMPC_if:
6892 assert(Argument.size() == 1 && ArgumentLoc.size() == 1)((Argument.size() == 1 && ArgumentLoc.size() == 1) ? static_cast
<void> (0) : __assert_fail ("Argument.size() == 1 && ArgumentLoc.size() == 1"
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6892, __PRETTY_FUNCTION__))
;
6893 Res = ActOnOpenMPIfClause(static_cast<OpenMPDirectiveKind>(Argument.back()),
6894 Expr, StartLoc, LParenLoc, ArgumentLoc.back(),
6895 DelimLoc, EndLoc);
6896 break;
6897 case OMPC_dist_schedule:
6898 Res = ActOnOpenMPDistScheduleClause(
6899 static_cast<OpenMPDistScheduleClauseKind>(Argument.back()), Expr,
6900 StartLoc, LParenLoc, ArgumentLoc.back(), DelimLoc, EndLoc);
6901 break;
6902 case OMPC_defaultmap:
6903 enum { Modifier, DefaultmapKind };
6904 Res = ActOnOpenMPDefaultmapClause(
6905 static_cast<OpenMPDefaultmapClauseModifier>(Argument[Modifier]),
6906 static_cast<OpenMPDefaultmapClauseKind>(Argument[DefaultmapKind]),
6907 StartLoc, LParenLoc, ArgumentLoc[Modifier], ArgumentLoc[DefaultmapKind],
6908 EndLoc);
6909 break;
6910 case OMPC_final:
6911 case OMPC_num_threads:
6912 case OMPC_safelen:
6913 case OMPC_simdlen:
6914 case OMPC_collapse:
6915 case OMPC_default:
6916 case OMPC_proc_bind:
6917 case OMPC_private:
6918 case OMPC_firstprivate:
6919 case OMPC_lastprivate:
6920 case OMPC_shared:
6921 case OMPC_reduction:
6922 case OMPC_linear:
6923 case OMPC_aligned:
6924 case OMPC_copyin:
6925 case OMPC_copyprivate:
6926 case OMPC_ordered:
6927 case OMPC_nowait:
6928 case OMPC_untied:
6929 case OMPC_mergeable:
6930 case OMPC_threadprivate:
6931 case OMPC_flush:
6932 case OMPC_read:
6933 case OMPC_write:
6934 case OMPC_update:
6935 case OMPC_capture:
6936 case OMPC_seq_cst:
6937 case OMPC_depend:
6938 case OMPC_device:
6939 case OMPC_threads:
6940 case OMPC_simd:
6941 case OMPC_map:
6942 case OMPC_num_teams:
6943 case OMPC_thread_limit:
6944 case OMPC_priority:
6945 case OMPC_grainsize:
6946 case OMPC_nogroup:
6947 case OMPC_num_tasks:
6948 case OMPC_hint:
6949 case OMPC_unknown:
6950 case OMPC_uniform:
6951 case OMPC_to:
6952 case OMPC_from:
6953 case OMPC_use_device_ptr:
6954 case OMPC_is_device_ptr:
6955 llvm_unreachable("Clause is not allowed.")::llvm::llvm_unreachable_internal("Clause is not allowed.", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 6955)
;
6956 }
6957 return Res;
6958}
6959
6960static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1,
6961 OpenMPScheduleClauseModifier M2,
6962 SourceLocation M1Loc, SourceLocation M2Loc) {
6963 if (M1 == OMPC_SCHEDULE_MODIFIER_unknown && M1Loc.isValid()) {
6964 SmallVector<unsigned, 2> Excluded;
6965 if (M2 != OMPC_SCHEDULE_MODIFIER_unknown)
6966 Excluded.push_back(M2);
6967 if (M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic)
6968 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_monotonic);
6969 if (M2 == OMPC_SCHEDULE_MODIFIER_monotonic)
6970 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_nonmonotonic);
6971 S.Diag(M1Loc, diag::err_omp_unexpected_clause_value)
6972 << getListOfPossibleValues(OMPC_schedule,
6973 /*First=*/OMPC_SCHEDULE_MODIFIER_unknown + 1,
6974 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
6975 Excluded)
6976 << getOpenMPClauseName(OMPC_schedule);
6977 return true;
6978 }
6979 return false;
6980}
6981
6982OMPClause *Sema::ActOnOpenMPScheduleClause(
6983 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
6984 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
6985 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
6986 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
6987 if (checkScheduleModifiers(*this, M1, M2, M1Loc, M2Loc) ||
6988 checkScheduleModifiers(*this, M2, M1, M2Loc, M1Loc))
6989 return nullptr;
6990 // OpenMP, 2.7.1, Loop Construct, Restrictions
6991 // Either the monotonic modifier or the nonmonotonic modifier can be specified
6992 // but not both.
6993 if ((M1 == M2 && M1 != OMPC_SCHEDULE_MODIFIER_unknown) ||
6994 (M1 == OMPC_SCHEDULE_MODIFIER_monotonic &&
6995 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) ||
6996 (M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic &&
6997 M2 == OMPC_SCHEDULE_MODIFIER_monotonic)) {
6998 Diag(M2Loc, diag::err_omp_unexpected_schedule_modifier)
6999 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M2)
7000 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M1);
7001 return nullptr;
7002 }
7003 if (Kind == OMPC_SCHEDULE_unknown) {
7004 std::string Values;
7005 if (M1Loc.isInvalid() && M2Loc.isInvalid()) {
7006 unsigned Exclude[] = {OMPC_SCHEDULE_unknown};
7007 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7008 /*Last=*/OMPC_SCHEDULE_MODIFIER_last,
7009 Exclude);
7010 } else {
7011 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
7012 /*Last=*/OMPC_SCHEDULE_unknown);
7013 }
7014 Diag(KindLoc, diag::err_omp_unexpected_clause_value)
7015 << Values << getOpenMPClauseName(OMPC_schedule);
7016 return nullptr;
7017 }
7018 // OpenMP, 2.7.1, Loop Construct, Restrictions
7019 // The nonmonotonic modifier can only be specified with schedule(dynamic) or
7020 // schedule(guided).
7021 if ((M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
7022 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
7023 Kind != OMPC_SCHEDULE_dynamic && Kind != OMPC_SCHEDULE_guided) {
7024 Diag(M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ? M1Loc : M2Loc,
7025 diag::err_omp_schedule_nonmonotonic_static);
7026 return nullptr;
7027 }
7028 Expr *ValExpr = ChunkSize;
7029 Stmt *HelperValStmt = nullptr;
7030 if (ChunkSize) {
7031 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() &&
7032 !ChunkSize->isInstantiationDependent() &&
7033 !ChunkSize->containsUnexpandedParameterPack()) {
7034 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart();
7035 ExprResult Val =
7036 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize);
7037 if (Val.isInvalid())
7038 return nullptr;
7039
7040 ValExpr = Val.get();
7041
7042 // OpenMP [2.7.1, Restrictions]
7043 // chunk_size must be a loop invariant integer expression with a positive
7044 // value.
7045 llvm::APSInt Result;
7046 if (ValExpr->isIntegerConstantExpr(Result, Context)) {
7047 if (Result.isSigned() && !Result.isStrictlyPositive()) {
7048 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
7049 << "schedule" << 1 << ChunkSize->getSourceRange();
7050 return nullptr;
7051 }
7052 } else if (isParallelOrTaskRegion(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective()) &&
7053 !CurContext->isDependentContext()) {
7054 llvm::MapVector<Expr *, DeclRefExpr *> Captures;
7055 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
7056 HelperValStmt = buildPreInits(Context, Captures);
7057 }
7058 }
7059 }
7060
7061 return new (Context)
7062 OMPScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, Kind,
7063 ValExpr, HelperValStmt, M1, M1Loc, M2, M2Loc);
7064}
7065
7066OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
7067 SourceLocation StartLoc,
7068 SourceLocation EndLoc) {
7069 OMPClause *Res = nullptr;
7070 switch (Kind) {
7071 case OMPC_ordered:
7072 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc);
7073 break;
7074 case OMPC_nowait:
7075 Res = ActOnOpenMPNowaitClause(StartLoc, EndLoc);
7076 break;
7077 case OMPC_untied:
7078 Res = ActOnOpenMPUntiedClause(StartLoc, EndLoc);
7079 break;
7080 case OMPC_mergeable:
7081 Res = ActOnOpenMPMergeableClause(StartLoc, EndLoc);
7082 break;
7083 case OMPC_read:
7084 Res = ActOnOpenMPReadClause(StartLoc, EndLoc);
7085 break;
7086 case OMPC_write:
7087 Res = ActOnOpenMPWriteClause(StartLoc, EndLoc);
7088 break;
7089 case OMPC_update:
7090 Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc);
7091 break;
7092 case OMPC_capture:
7093 Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc);
7094 break;
7095 case OMPC_seq_cst:
7096 Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
7097 break;
7098 case OMPC_threads:
7099 Res = ActOnOpenMPThreadsClause(StartLoc, EndLoc);
7100 break;
7101 case OMPC_simd:
7102 Res = ActOnOpenMPSIMDClause(StartLoc, EndLoc);
7103 break;
7104 case OMPC_nogroup:
7105 Res = ActOnOpenMPNogroupClause(StartLoc, EndLoc);
7106 break;
7107 case OMPC_if:
7108 case OMPC_final:
7109 case OMPC_num_threads:
7110 case OMPC_safelen:
7111 case OMPC_simdlen:
7112 case OMPC_collapse:
7113 case OMPC_schedule:
7114 case OMPC_private:
7115 case OMPC_firstprivate:
7116 case OMPC_lastprivate:
7117 case OMPC_shared:
7118 case OMPC_reduction:
7119 case OMPC_linear:
7120 case OMPC_aligned:
7121 case OMPC_copyin:
7122 case OMPC_copyprivate:
7123 case OMPC_default:
7124 case OMPC_proc_bind:
7125 case OMPC_threadprivate:
7126 case OMPC_flush:
7127 case OMPC_depend:
7128 case OMPC_device:
7129 case OMPC_map:
7130 case OMPC_num_teams:
7131 case OMPC_thread_limit:
7132 case OMPC_priority:
7133 case OMPC_grainsize:
7134 case OMPC_num_tasks:
7135 case OMPC_hint:
7136 case OMPC_dist_schedule:
7137 case OMPC_defaultmap:
7138 case OMPC_unknown:
7139 case OMPC_uniform:
7140 case OMPC_to:
7141 case OMPC_from:
7142 case OMPC_use_device_ptr:
7143 case OMPC_is_device_ptr:
7144 llvm_unreachable("Clause is not allowed.")::llvm::llvm_unreachable_internal("Clause is not allowed.", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 7144)
;
7145 }
7146 return Res;
7147}
7148
7149OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc,
7150 SourceLocation EndLoc) {
7151 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->setNowaitRegion();
7152 return new (Context) OMPNowaitClause(StartLoc, EndLoc);
7153}
7154
7155OMPClause *Sema::ActOnOpenMPUntiedClause(SourceLocation StartLoc,
7156 SourceLocation EndLoc) {
7157 return new (Context) OMPUntiedClause(StartLoc, EndLoc);
7158}
7159
7160OMPClause *Sema::ActOnOpenMPMergeableClause(SourceLocation StartLoc,
7161 SourceLocation EndLoc) {
7162 return new (Context) OMPMergeableClause(StartLoc, EndLoc);
7163}
7164
7165OMPClause *Sema::ActOnOpenMPReadClause(SourceLocation StartLoc,
7166 SourceLocation EndLoc) {
7167 return new (Context) OMPReadClause(StartLoc, EndLoc);
7168}
7169
7170OMPClause *Sema::ActOnOpenMPWriteClause(SourceLocation StartLoc,
7171 SourceLocation EndLoc) {
7172 return new (Context) OMPWriteClause(StartLoc, EndLoc);
7173}
7174
7175OMPClause *Sema::ActOnOpenMPUpdateClause(SourceLocation StartLoc,
7176 SourceLocation EndLoc) {
7177 return new (Context) OMPUpdateClause(StartLoc, EndLoc);
7178}
7179
7180OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc,
7181 SourceLocation EndLoc) {
7182 return new (Context) OMPCaptureClause(StartLoc, EndLoc);
7183}
7184
7185OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
7186 SourceLocation EndLoc) {
7187 return new (Context) OMPSeqCstClause(StartLoc, EndLoc);
7188}
7189
7190OMPClause *Sema::ActOnOpenMPThreadsClause(SourceLocation StartLoc,
7191 SourceLocation EndLoc) {
7192 return new (Context) OMPThreadsClause(StartLoc, EndLoc);
7193}
7194
7195OMPClause *Sema::ActOnOpenMPSIMDClause(SourceLocation StartLoc,
7196 SourceLocation EndLoc) {
7197 return new (Context) OMPSIMDClause(StartLoc, EndLoc);
7198}
7199
7200OMPClause *Sema::ActOnOpenMPNogroupClause(SourceLocation StartLoc,
7201 SourceLocation EndLoc) {
7202 return new (Context) OMPNogroupClause(StartLoc, EndLoc);
7203}
7204
7205OMPClause *Sema::ActOnOpenMPVarListClause(
7206 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr,
7207 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc,
7208 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
7209 const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
7210 OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
7211 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
7212 SourceLocation DepLinMapLoc) {
7213 OMPClause *Res = nullptr;
7214 switch (Kind) {
7215 case OMPC_private:
7216 Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7217 break;
7218 case OMPC_firstprivate:
7219 Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7220 break;
7221 case OMPC_lastprivate:
7222 Res = ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7223 break;
7224 case OMPC_shared:
7225 Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc);
7226 break;
7227 case OMPC_reduction:
7228 Res = ActOnOpenMPReductionClause(VarList, StartLoc, LParenLoc, ColonLoc,
7229 EndLoc, ReductionIdScopeSpec, ReductionId);
7230 break;
7231 case OMPC_linear:
7232 Res = ActOnOpenMPLinearClause(VarList, TailExpr, StartLoc, LParenLoc,
7233 LinKind, DepLinMapLoc, ColonLoc, EndLoc);
7234 break;
7235 case OMPC_aligned:
7236 Res = ActOnOpenMPAlignedClause(VarList, TailExpr, StartLoc, LParenLoc,
7237 ColonLoc, EndLoc);
7238 break;
7239 case OMPC_copyin:
7240 Res = ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, EndLoc);
7241 break;
7242 case OMPC_copyprivate:
7243 Res = ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, EndLoc);
7244 break;
7245 case OMPC_flush:
7246 Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc);
7247 break;
7248 case OMPC_depend:
7249 Res = ActOnOpenMPDependClause(DepKind, DepLinMapLoc, ColonLoc, VarList,
7250 StartLoc, LParenLoc, EndLoc);
7251 break;
7252 case OMPC_map:
7253 Res = ActOnOpenMPMapClause(MapTypeModifier, MapType, IsMapTypeImplicit,
7254 DepLinMapLoc, ColonLoc, VarList, StartLoc,
7255 LParenLoc, EndLoc);
7256 break;
7257 case OMPC_to:
7258 Res = ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
7259 break;
7260 case OMPC_from:
7261 Res = ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc, EndLoc);
7262 break;
7263 case OMPC_use_device_ptr:
7264 Res = ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
7265 break;
7266 case OMPC_is_device_ptr:
7267 Res = ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc);
7268 break;
7269 case OMPC_if:
7270 case OMPC_final:
7271 case OMPC_num_threads:
7272 case OMPC_safelen:
7273 case OMPC_simdlen:
7274 case OMPC_collapse:
7275 case OMPC_default:
7276 case OMPC_proc_bind:
7277 case OMPC_schedule:
7278 case OMPC_ordered:
7279 case OMPC_nowait:
7280 case OMPC_untied:
7281 case OMPC_mergeable:
7282 case OMPC_threadprivate:
7283 case OMPC_read:
7284 case OMPC_write:
7285 case OMPC_update:
7286 case OMPC_capture:
7287 case OMPC_seq_cst:
7288 case OMPC_device:
7289 case OMPC_threads:
7290 case OMPC_simd:
7291 case OMPC_num_teams:
7292 case OMPC_thread_limit:
7293 case OMPC_priority:
7294 case OMPC_grainsize:
7295 case OMPC_nogroup:
7296 case OMPC_num_tasks:
7297 case OMPC_hint:
7298 case OMPC_dist_schedule:
7299 case OMPC_defaultmap:
7300 case OMPC_unknown:
7301 case OMPC_uniform:
7302 llvm_unreachable("Clause is not allowed.")::llvm::llvm_unreachable_internal("Clause is not allowed.", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 7302)
;
7303 }
7304 return Res;
7305}
7306
7307ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
7308 ExprObjectKind OK, SourceLocation Loc) {
7309 ExprResult Res = BuildDeclRefExpr(
7310 Capture, Capture->getType().getNonReferenceType(), VK_LValue, Loc);
7311 if (!Res.isUsable())
7312 return ExprError();
7313 if (OK == OK_Ordinary && !getLangOpts().CPlusPlus) {
7314 Res = CreateBuiltinUnaryOp(Loc, UO_Deref, Res.get());
7315 if (!Res.isUsable())
7316 return ExprError();
7317 }
7318 if (VK != VK_LValue && Res.get()->isGLValue()) {
7319 Res = DefaultLvalueConversion(Res.get());
7320 if (!Res.isUsable())
7321 return ExprError();
7322 }
7323 return Res;
7324}
7325
7326static std::pair<ValueDecl *, bool>
7327getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
7328 SourceRange &ERange, bool AllowArraySection = false) {
7329 if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() ||
7330 RefExpr->containsUnexpandedParameterPack())
7331 return std::make_pair(nullptr, true);
7332
7333 // OpenMP [3.1, C/C++]
7334 // A list item is a variable name.
7335 // OpenMP [2.9.3.3, Restrictions, p.1]
7336 // A variable that is part of another variable (as an array or
7337 // structure element) cannot appear in a private clause.
7338 RefExpr = RefExpr->IgnoreParens();
7339 enum {
7340 NoArrayExpr = -1,
7341 ArraySubscript = 0,
7342 OMPArraySection = 1
7343 } IsArrayExpr = NoArrayExpr;
7344 if (AllowArraySection) {
7345 if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) {
7346 auto *Base = ASE->getBase()->IgnoreParenImpCasts();
7347 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
7348 Base = TempASE->getBase()->IgnoreParenImpCasts();
7349 RefExpr = Base;
7350 IsArrayExpr = ArraySubscript;
7351 } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) {
7352 auto *Base = OASE->getBase()->IgnoreParenImpCasts();
7353 while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base))
7354 Base = TempOASE->getBase()->IgnoreParenImpCasts();
7355 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
7356 Base = TempASE->getBase()->IgnoreParenImpCasts();
7357 RefExpr = Base;
7358 IsArrayExpr = OMPArraySection;
7359 }
7360 }
7361 ELoc = RefExpr->getExprLoc();
7362 ERange = RefExpr->getSourceRange();
7363 RefExpr = RefExpr->IgnoreParenImpCasts();
7364 auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
7365 auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr);
7366 if ((!DE || !isa<VarDecl>(DE->getDecl())) &&
7367 (S.getCurrentThisType().isNull() || !ME ||
7368 !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) ||
7369 !isa<FieldDecl>(ME->getMemberDecl()))) {
7370 if (IsArrayExpr != NoArrayExpr)
7371 S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr
7372 << ERange;
7373 else {
7374 S.Diag(ELoc,
7375 AllowArraySection
7376 ? diag::err_omp_expected_var_name_member_expr_or_array_item
7377 : diag::err_omp_expected_var_name_member_expr)
7378 << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange;
7379 }
7380 return std::make_pair(nullptr, false);
7381 }
7382 return std::make_pair(DE ? DE->getDecl() : ME->getMemberDecl(), false);
7383}
7384
7385OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
7386 SourceLocation StartLoc,
7387 SourceLocation LParenLoc,
7388 SourceLocation EndLoc) {
7389 SmallVector<Expr *, 8> Vars;
7390 SmallVector<Expr *, 8> PrivateCopies;
7391 for (auto &RefExpr : VarList) {
7392 assert(RefExpr && "NULL expr in OpenMP private clause.")((RefExpr && "NULL expr in OpenMP private clause.") ?
static_cast<void> (0) : __assert_fail ("RefExpr && \"NULL expr in OpenMP private clause.\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 7392, __PRETTY_FUNCTION__))
;
7393 SourceLocation ELoc;
7394 SourceRange ERange;
7395 Expr *SimpleRefExpr = RefExpr;
7396 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
7397 if (Res.second) {
7398 // It will be analyzed later.
7399 Vars.push_back(RefExpr);
7400 PrivateCopies.push_back(nullptr);
7401 }
7402 ValueDecl *D = Res.first;
7403 if (!D)
7404 continue;
7405
7406 QualType Type = D->getType();
7407 auto *VD = dyn_cast<VarDecl>(D);
7408
7409 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3]
7410 // A variable that appears in a private clause must not have an incomplete
7411 // type or a reference type.
7412 if (RequireCompleteType(ELoc, Type, diag::err_omp_private_incomplete_type))
7413 continue;
7414 Type = Type.getNonReferenceType();
7415
7416 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
7417 // in a Construct]
7418 // Variables with the predetermined data-sharing attributes may not be
7419 // listed in data-sharing attributes clauses, except for the cases
7420 // listed below. For these exceptions only, listing a predetermined
7421 // variable in a data-sharing attribute clause is allowed and overrides
7422 // the variable's predetermined data-sharing attributes.
7423 DSAStackTy::DSAVarData DVar = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getTopDSA(D, false);
7424 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) {
7425 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind)
7426 << getOpenMPClauseName(OMPC_private);
7427 ReportOriginalDSA(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, D, DVar);
7428 continue;
7429 }
7430
7431 auto CurrDir = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getCurrentDirective();
7432 // Variably modified types are not supported for tasks.
7433 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() &&
7434 isOpenMPTaskingDirective(CurrDir)) {
7435 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported)
7436 << getOpenMPClauseName(OMPC_private) << Type
7437 << getOpenMPDirectiveName(CurrDir);
7438 bool IsDecl =
7439 !VD ||
7440 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
7441 Diag(D->getLocation(),
7442 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
7443 << D;
7444 continue;
7445 }
7446
7447 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3]
7448 // A list item cannot appear in both a map clause and a data-sharing
7449 // attribute clause on the same construct
7450 if (CurrDir == OMPD_target || CurrDir == OMPD_target_parallel ||
7451 CurrDir == OMPD_target_teams ||
7452 CurrDir == OMPD_target_teams_distribute ||
7453 CurrDir == OMPD_target_teams_distribute_parallel_for ||
7454 CurrDir == OMPD_target_teams_distribute_parallel_for_simd) {
7455 OpenMPClauseKind ConflictKind;
7456 if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->checkMappableExprComponentListsForDecl(
7457 VD, /*CurrentRegionOnly=*/true,
7458 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef,
7459 OpenMPClauseKind WhereFoundClauseKind) -> bool {
7460 ConflictKind = WhereFoundClauseKind;
7461 return true;
7462 })) {
7463 Diag(ELoc, diag::err_omp_variable_in_given_clause_and_dsa)
7464 << getOpenMPClauseName(OMPC_private)
7465 << getOpenMPClauseName(ConflictKind)
7466 << getOpenMPDirectiveName(CurrDir);
7467 ReportOriginalDSA(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
, D, DVar);
7468 continue;
7469 }
7470 }
7471
7472 // OpenMP [2.9.3.3, Restrictions, C/C++, p.1]
7473 // A variable of class type (or array thereof) that appears in a private
7474 // clause requires an accessible, unambiguous default constructor for the
7475 // class type.
7476 // Generate helper private variable and initialize it with the default
7477 // value. The address of the original variable is replaced by the address of
7478 // the new private variable in CodeGen. This new variable is not added to
7479 // IdResolver, so the code in the OpenMP region uses original variable for
7480 // proper diagnostics.
7481 Type = Type.getUnqualifiedType();
7482 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(),
7483 D->hasAttrs() ? &D->getAttrs() : nullptr);
7484 ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false);
7485 if (VDPrivate->isInvalidDecl())
7486 continue;
7487 auto VDPrivateRefExpr = buildDeclRefExpr(
7488 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc);
7489
7490 DeclRefExpr *Ref = nullptr;
7491 if (!VD && !CurContext->isDependentContext())
7492 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false);
7493 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->addDSA(D, RefExpr->IgnoreParens(), OMPC_private, Ref);
7494 Vars.push_back((VD || CurContext->isDependentContext())
7495 ? RefExpr->IgnoreParens()
7496 : Ref);
7497 PrivateCopies.push_back(VDPrivateRefExpr);
7498 }
7499
7500 if (Vars.empty())
7501 return nullptr;
7502
7503 return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars,
7504 PrivateCopies);
7505}
7506
7507namespace {
7508class DiagsUninitializedSeveretyRAII {
7509private:
7510 DiagnosticsEngine &Diags;
7511 SourceLocation SavedLoc;
7512 bool IsIgnored;
7513
7514public:
7515 DiagsUninitializedSeveretyRAII(DiagnosticsEngine &Diags, SourceLocation Loc,
7516 bool IsIgnored)
7517 : Diags(Diags), SavedLoc(Loc), IsIgnored(IsIgnored) {
7518 if (!IsIgnored) {
7519 Diags.setSeverity(/*Diag*/ diag::warn_uninit_self_reference_in_init,
7520 /*Map*/ diag::Severity::Ignored, Loc);
7521 }
7522 }
7523 ~DiagsUninitializedSeveretyRAII() {
7524 if (!IsIgnored)
7525 Diags.popMappings(SavedLoc);
7526 }
7527};
7528}
7529
7530OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
7531 SourceLocation StartLoc,
7532 SourceLocation LParenLoc,
7533 SourceLocation EndLoc) {
7534 SmallVector<Expr *, 8> Vars;
7535 SmallVector<Expr *, 8> PrivateCopies;
7536 SmallVector<Expr *, 8> Inits;
7537 SmallVector<Decl *, 4> ExprCaptures;
7538 bool IsImplicitClause =
7539 StartLoc.isInvalid() && LParenLoc.isInvalid() && EndLoc.isInvalid();
7540 auto ImplicitClauseLoc = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)
->getConstructLoc();
7541
7542 for (auto &RefExpr : VarList) {
7543 assert(RefExpr && "NULL expr in OpenMP firstprivate clause.")((RefExpr && "NULL expr in OpenMP firstprivate clause."
) ? static_cast<void> (0) : __assert_fail ("RefExpr && \"NULL expr in OpenMP firstprivate clause.\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/clang/lib/Sema/SemaOpenMP.cpp"
, 7543, __PRETTY_FUNCTION__))
;
7544 SourceLocation ELoc;
7545 SourceRange ERange;
7546 Expr *SimpleRefExpr = RefExpr;
7547 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
7548 if (Res.second) {
7549 // It will be analyzed later.
7550 Vars.push_back(RefExpr);
7551 PrivateCopies.push_back(nullptr);
7552 Inits.push_back(nullptr);
7553 }
7554 Value