14#ifndef LLVM_CLANG_AST_STMTOPENMP_H
15#define LLVM_CLANG_AST_STMTOPENMP_H
152 LastSubStmt = LOOPVAR_REF
157 Stmt *SubStmts[LastSubStmt + 1] = {};
159 OMPCanonicalLoop() :
Stmt(
StmtClass::OMPCanonicalLoopClass) {}
168 S->setLoopStmt(LoopStmt);
169 S->setDistanceFunc(DistanceFunc);
170 S->setLoopVarFunc(LoopVarFunc);
171 S->setLoopVarRef(LoopVarRef);
181 return S->getStmtClass() == StmtClass::OMPCanonicalLoopClass;
190 return child_range(&SubStmts[0], &SubStmts[0] + LastSubStmt + 1);
202 assert((isa<ForStmt>(S) || isa<CXXForRangeStmt>(S)) &&
203 "Canonical loop must be a for loop (range-based or otherwise)");
204 SubStmts[LOOP_STMT] = S;
216 return cast<CapturedStmt>(SubStmts[DISTANCE_FUNC]);
219 return cast<CapturedStmt>(SubStmts[DISTANCE_FUNC]);
222 assert(S &&
"Expected non-null captured statement");
223 SubStmts[DISTANCE_FUNC] = S;
237 return cast<CapturedStmt>(SubStmts[LOOPVAR_FUNC]);
240 return cast<CapturedStmt>(SubStmts[LOOPVAR_FUNC]);
243 assert(S &&
"Expected non-null captured statement");
244 SubStmts[LOOPVAR_FUNC] = S;
251 return cast<DeclRefExpr>(SubStmts[LOOPVAR_REF]);
254 return cast<DeclRefExpr>(SubStmts[LOOPVAR_REF]);
257 assert(E &&
"Expected non-null loop variable");
258 SubStmts[LOOPVAR_REF] = E;
297 :
Stmt(SC), Kind(K), StartLoc(
std::move(StartLoc)),
298 EndLoc(
std::move(EndLoc)) {}
300 template <
typename T,
typename... Params>
302 Stmt *AssociatedStmt,
unsigned NumChildren,
305 C.Allocate(
sizeof(T) + OMPChildren::size(Clauses.size(), AssociatedStmt,
309 auto *
Data = OMPChildren::Create(
reinterpret_cast<T *
>(Mem) + 1, Clauses,
310 AssociatedStmt, NumChildren);
311 auto *Inst =
new (Mem) T(std::forward<Params>(
P)...);
316 template <
typename T,
typename... Params>
318 bool HasAssociatedStmt,
unsigned NumChildren,
321 C.Allocate(
sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
325 OMPChildren::CreateEmpty(
reinterpret_cast<T *
>(Mem) + 1, NumClauses,
326 HasAssociatedStmt, NumChildren);
327 auto *Inst =
new (Mem) T(std::forward<Params>(
P)...);
332 template <
typename T>
334 bool HasAssociatedStmt =
false,
335 unsigned NumChildren = 0) {
337 C.Allocate(
sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
341 OMPChildren::CreateEmpty(
reinterpret_cast<T *
>(Mem) + 1, NumClauses,
342 HasAssociatedStmt, NumChildren);
343 auto *Inst =
new (Mem) T;
351 :
public llvm::iterator_adaptor_base<
352 used_clauses_child_iterator, ArrayRef<OMPClause *>::iterator,
353 std::forward_iterator_tag, Stmt *, ptrdiff_t, Stmt *, Stmt *> {
358 if (ChildI != ChildEnd)
360 while (this->I != End) {
362 if (this->I != End) {
363 ChildI = (*this->I)->used_children().begin();
364 ChildEnd = (*this->I)->used_children().end();
365 if (ChildI != ChildEnd)
375 if (this->I != End) {
376 ChildI = (*this->I)->used_children().begin();
377 ChildEnd = (*this->I)->used_children().end();
386 if (ChildI != ChildEnd)
388 if (this->I != End) {
390 if (this->I != End) {
391 ChildI = (*this->I)->used_children().begin();
392 ChildEnd = (*this->I)->used_children().end();
400 static llvm::iterator_range<used_clauses_child_iterator>
411 template <
typename SpecificClause>
413 :
public llvm::iterator_adaptor_base<
414 specific_clause_iterator<SpecificClause>,
415 ArrayRef<OMPClause *>::const_iterator, std::forward_iterator_tag,
416 const SpecificClause *, ptrdiff_t, const SpecificClause *,
417 const SpecificClause *> {
420 void SkipToNextClause() {
421 while (this->I != End && !isa<SpecificClause>(*this->I))
433 return cast<SpecificClause>(*this->I);
444 template <
typename SpecificClause>
445 static llvm::iterator_range<specific_clause_iterator<SpecificClause>>
452 template <
typename SpecificClause>
453 llvm::iterator_range<specific_clause_iterator<SpecificClause>>
455 return getClausesOfKind<SpecificClause>(
clauses());
463 template <
typename SpecificClause>
465 auto ClausesOfKind = getClausesOfKind<SpecificClause>(Clauses);
467 if (ClausesOfKind.begin() != ClausesOfKind.end()) {
468 assert(std::next(ClausesOfKind.begin()) == ClausesOfKind.end() &&
469 "There are at least 2 clauses of the specified kind");
470 return *ClausesOfKind.begin();
475 template <
typename SpecificClause>
477 return getSingleClause<SpecificClause>(
clauses());
482 template <
typename SpecificClause>
484 auto Clauses = getClausesOfKind<SpecificClause>();
485 return Clauses.begin() != Clauses.end();
526 "Expected directive with the associated statement.");
536 "Expected directive with the associated statement.");
545 "Expected directive with the associated statement.");
559 return S->getStmtClass() >= firstOMPExecutableDirectiveConstant &&
560 S->getStmtClass() <= lastOMPExecutableDirectiveConstant;
598 "Expected directive with the associated statement.");
616 bool HasCancel =
false;
625 llvm::omp::OMPD_parallel, StartLoc, EndLoc) {}
638 void setHasCancel(
bool Has) { HasCancel = Has; }
652 static OMPParallelDirective *
653 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
654 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
662 static OMPParallelDirective *
CreateEmpty(
const ASTContext &
C,
663 unsigned NumClauses, EmptyShell);
818 Cond !=
nullptr &&
Init !=
nullptr &&
Inc !=
nullptr;
853 for (
unsigned I = 0; I < Size; ++I) {
884 bool TryImperfectlyNestedLoops);
886 bool TryImperfectlyNestedLoops) {
888 TryImperfectlyNestedLoops);
896 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback,
898 OnTransformationCallback);
902 llvm::function_ref<
bool(
unsigned,
const Stmt *)> Callback,
904 OnTransformationCallback) {
905 auto &&NewCallback = [Callback](
unsigned Cnt,
Stmt *CurStmt) {
906 return Callback(Cnt, CurStmt);
908 auto &&NewTransformCb =
910 OnTransformationCallback(A);
913 NumLoops, NewCallback, NewTransformCb);
921 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback) {
923 return doForAllLoops(CurStmt, TryImperfectlyNestedLoops, NumLoops, Callback,
929 llvm::function_ref<
bool(
unsigned,
const Stmt *)> Callback) {
930 auto &&NewCallback = [Callback](
unsigned Cnt,
const Stmt *CurStmt) {
931 return Callback(Cnt, CurStmt);
934 NumLoops, NewCallback);
940 Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
941 llvm::function_ref<
void(
unsigned,
Stmt *,
Stmt *)> Callback);
943 const Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
944 llvm::function_ref<
void(
unsigned,
const Stmt *,
const Stmt *)> Callback) {
945 auto &&NewCallback = [Callback](
unsigned Cnt,
Stmt *Loop,
Stmt *Body) {
946 Callback(Cnt, Loop, Body);
949 NumLoops, NewCallback);
953 if (
auto *D = dyn_cast<OMPExecutableDirective>(T))
964 unsigned NumGeneratedLoops = 0;
1023 IterationVariableOffset = 0,
1024 LastIterationOffset = 1,
1025 CalcLastIterationOffset = 2,
1026 PreConditionOffset = 3,
1037 IsLastIterVariableOffset = 8,
1038 LowerBoundVariableOffset = 9,
1039 UpperBoundVariableOffset = 10,
1040 StrideVariableOffset = 11,
1041 EnsureUpperBoundOffset = 12,
1042 NextLowerBoundOffset = 13,
1043 NextUpperBoundOffset = 14,
1044 NumIterationsOffset = 15,
1046 WorksharingEnd = 16,
1047 PrevLowerBoundVariableOffset = 16,
1048 PrevUpperBoundVariableOffset = 17,
1050 PrevEnsureUpperBoundOffset = 19,
1051 CombinedLowerBoundVariableOffset = 20,
1052 CombinedUpperBoundVariableOffset = 21,
1053 CombinedEnsureUpperBoundOffset = 22,
1054 CombinedInitOffset = 23,
1055 CombinedConditionOffset = 24,
1056 CombinedNextLowerBoundOffset = 25,
1057 CombinedNextUpperBoundOffset = 26,
1058 CombinedDistConditionOffset = 27,
1059 CombinedParForInDistConditionOffset = 28,
1063 CombinedDistributeEnd = 29,
1068 auto **Storage =
reinterpret_cast<Expr **
>(
1074 MutableArrayRef<Expr *> getPrivateCounters() {
1075 auto **Storage =
reinterpret_cast<Expr **
>(
1082 MutableArrayRef<Expr *> getInits() {
1083 auto **Storage =
reinterpret_cast<Expr **
>(
1090 MutableArrayRef<Expr *> getUpdates() {
1091 auto **Storage =
reinterpret_cast<Expr **
>(
1098 MutableArrayRef<Expr *> getFinals() {
1099 auto **Storage =
reinterpret_cast<Expr **
>(
1106 MutableArrayRef<Expr *> getDependentCounters() {
1107 auto **Storage =
reinterpret_cast<Expr **
>(
1114 MutableArrayRef<Expr *> getDependentInits() {
1115 auto **Storage =
reinterpret_cast<Expr **
>(
1122 MutableArrayRef<Expr *> getFinalsConditions() {
1123 auto **Storage =
reinterpret_cast<Expr **
>(
1140 unsigned CollapsedNum)
1146 return CombinedDistributeEnd;
1149 return WorksharingEnd;
1183 "expected worksharing loop directive");
1191 "expected worksharing loop directive");
1199 "expected worksharing loop directive");
1207 "expected worksharing loop directive");
1215 "expected worksharing loop directive");
1223 "expected worksharing loop directive");
1231 "expected worksharing loop directive");
1239 "expected worksharing loop directive");
1244 "expected loop bound sharing directive");
1249 "expected loop bound sharing directive");
1254 "expected loop bound sharing directive");
1259 "expected loop bound sharing directive");
1264 "expected loop bound sharing directive");
1269 "expected loop bound sharing directive");
1274 "expected loop bound sharing directive");
1279 "expected loop bound sharing directive");
1284 "expected loop bound sharing directive");
1289 "expected loop bound sharing directive");
1294 "expected loop bound sharing directive");
1299 "expected loop bound distribute sharing directive");
1304 "expected loop bound distribute sharing directive");
1306 CombParForInDistCond;
1342 "expected worksharing loop directive");
1350 "expected worksharing loop directive");
1358 "expected worksharing loop directive");
1366 "expected worksharing loop directive");
1374 "expected worksharing loop directive");
1382 "expected worksharing loop directive");
1390 "expected worksharing loop directive");
1398 "expected worksharing loop directive");
1403 "expected loop bound sharing directive");
1408 "expected loop bound sharing directive");
1413 "expected loop bound sharing directive");
1418 "expected loop bound sharing directive");
1423 "expected loop bound sharing directive");
1424 return cast<Expr>(
Data->
getChildren()[CombinedLowerBoundVariableOffset]);
1428 "expected loop bound sharing directive");
1429 return cast<Expr>(
Data->
getChildren()[CombinedUpperBoundVariableOffset]);
1433 "expected loop bound sharing directive");
1434 return cast<Expr>(
Data->
getChildren()[CombinedEnsureUpperBoundOffset]);
1438 "expected loop bound sharing directive");
1443 "expected loop bound sharing directive");
1448 "expected loop bound sharing directive");
1453 "expected loop bound sharing directive");
1458 "expected loop bound distribute sharing directive");
1463 "expected loop bound distribute sharing directive");
1464 return cast<Expr>(
Data->
getChildren()[CombinedParForInDistConditionOffset]);
1524 T->
getStmtClass() == OMPParallelForSimdDirectiveClass ||
1527 T->
getStmtClass() == OMPMaskedTaskLoopDirectiveClass ||
1528 T->
getStmtClass() == OMPMaskedTaskLoopSimdDirectiveClass ||
1529 T->
getStmtClass() == OMPMasterTaskLoopDirectiveClass ||
1530 T->
getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass ||
1532 T->
getStmtClass() == OMPTeamsGenericLoopDirectiveClass ||
1533 T->
getStmtClass() == OMPTargetTeamsGenericLoopDirectiveClass ||
1534 T->
getStmtClass() == OMPParallelGenericLoopDirectiveClass ||
1535 T->
getStmtClass() == OMPTargetParallelGenericLoopDirectiveClass ||
1536 T->
getStmtClass() == OMPParallelMaskedTaskLoopDirectiveClass ||
1537 T->
getStmtClass() == OMPParallelMaskedTaskLoopSimdDirectiveClass ||
1538 T->
getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass ||
1539 T->
getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass ||
1541 T->
getStmtClass() == OMPTargetParallelForDirectiveClass ||
1542 T->
getStmtClass() == OMPDistributeParallelForDirectiveClass ||
1543 T->
getStmtClass() == OMPDistributeParallelForSimdDirectiveClass ||
1544 T->
getStmtClass() == OMPDistributeSimdDirectiveClass ||
1545 T->
getStmtClass() == OMPTargetParallelForSimdDirectiveClass ||
1547 T->
getStmtClass() == OMPTeamsDistributeDirectiveClass ||
1548 T->
getStmtClass() == OMPTeamsDistributeSimdDirectiveClass ||
1550 OMPTeamsDistributeParallelForSimdDirectiveClass ||
1551 T->
getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass ||
1553 OMPTargetTeamsDistributeParallelForDirectiveClass ||
1555 OMPTargetTeamsDistributeParallelForSimdDirectiveClass ||
1556 T->
getStmtClass() == OMPTargetTeamsDistributeDirectiveClass ||
1557 T->
getStmtClass() == OMPTargetTeamsDistributeSimdDirectiveClass;
1580 unsigned CollapsedNum)
1582 EndLoc, CollapsedNum) {}
1603 static OMPSimdDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1604 SourceLocation EndLoc,
unsigned CollapsedNum,
1605 ArrayRef<OMPClause *> Clauses,
1606 Stmt *AssociatedStmt,
1607 const HelperExprs &Exprs);
1616 static OMPSimdDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
1617 unsigned CollapsedNum, EmptyShell);
1637 bool HasCancel =
false;
1646 unsigned CollapsedNum)
1648 EndLoc, CollapsedNum) {}
1659 void setTaskReductionRefExpr(Expr *E) {
1661 llvm::omp::OMPD_for)] = E;
1665 void setHasCancel(
bool Has) { HasCancel = Has; }
1681 static OMPForDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1682 SourceLocation EndLoc,
unsigned CollapsedNum,
1683 ArrayRef<OMPClause *> Clauses,
1684 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
1685 Expr *TaskRedRef,
bool HasCancel);
1694 static OMPForDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
1695 unsigned CollapsedNum, EmptyShell);
1733 unsigned CollapsedNum)
1735 StartLoc, EndLoc, CollapsedNum) {}
1756 static OMPForSimdDirective *
1757 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1758 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1759 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
1768 static OMPForSimdDirective *
CreateEmpty(
const ASTContext &
C,
1769 unsigned NumClauses,
1770 unsigned CollapsedNum, EmptyShell);
1791 bool HasCancel =
false;
1800 llvm::omp::OMPD_sections, StartLoc, EndLoc) {}
1813 void setHasCancel(
bool Has) { HasCancel = Has; }
1827 static OMPSectionsDirective *
1828 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1829 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
1838 static OMPSectionsDirective *
CreateEmpty(
const ASTContext &
C,
1839 unsigned NumClauses, EmptyShell);
1868 bool HasCancel =
false;
1877 llvm::omp::OMPD_section, StartLoc, EndLoc) {}
1895 static OMPSectionDirective *
Create(
const ASTContext &
C,
1896 SourceLocation StartLoc,
1897 SourceLocation EndLoc,
1898 Stmt *AssociatedStmt,
bool HasCancel);
1904 static OMPSectionDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
1935 StartLoc, EndLoc) {}
1952 static OMPSingleDirective *
1953 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1954 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1962 static OMPSingleDirective *
CreateEmpty(
const ASTContext &
C,
1963 unsigned NumClauses, EmptyShell);
1986 StartLoc, EndLoc) {}
2002 static OMPMasterDirective *
Create(
const ASTContext &
C,
2003 SourceLocation StartLoc,
2004 SourceLocation EndLoc,
2005 Stmt *AssociatedStmt);
2011 static OMPMasterDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2038 llvm::omp::OMPD_critical, StartLoc, EndLoc),
2052 void setDirectiveName(
const DeclarationNameInfo &Name) { DirName = Name; }
2064 static OMPCriticalDirective *
2065 Create(
const ASTContext &
C,
const DeclarationNameInfo &Name,
2066 SourceLocation StartLoc, SourceLocation EndLoc,
2067 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2074 static OMPCriticalDirective *
CreateEmpty(
const ASTContext &
C,
2075 unsigned NumClauses, EmptyShell);
2100 bool HasCancel =
false;
2109 unsigned CollapsedNum)
2111 llvm::omp::OMPD_parallel_for, StartLoc, EndLoc,
2124 void setTaskReductionRefExpr(Expr *E) {
2126 llvm::omp::OMPD_parallel_for)] = E;
2130 void setHasCancel(
bool Has) { HasCancel = Has; }
2146 static OMPParallelForDirective *
2147 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2148 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2149 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
2159 static OMPParallelForDirective *
CreateEmpty(
const ASTContext &
C,
2160 unsigned NumClauses,
2161 unsigned CollapsedNum,
2178 return T->
getStmtClass() == OMPParallelForDirectiveClass;
2202 unsigned CollapsedNum)
2204 llvm::omp::OMPD_parallel_for_simd, StartLoc, EndLoc,
2227 static OMPParallelForSimdDirective *
2228 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2229 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2230 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
2239 static OMPParallelForSimdDirective *
CreateEmpty(
const ASTContext &
C,
2240 unsigned NumClauses,
2241 unsigned CollapsedNum,
2245 return T->
getStmtClass() == OMPParallelForSimdDirectiveClass;
2263 llvm::omp::OMPD_parallel_master, StartLoc,
2268 llvm::omp::OMPD_parallel_master,
2285 static OMPParallelMasterDirective *
2286 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2287 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef);
2295 static OMPParallelMasterDirective *
2296 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2308 return T->
getStmtClass() == OMPParallelMasterDirectiveClass;
2326 llvm::omp::OMPD_parallel_masked, StartLoc,
2331 llvm::omp::OMPD_parallel_masked,
2348 static OMPParallelMaskedDirective *
2349 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2350 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef);
2358 static OMPParallelMaskedDirective *
2359 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2371 return T->
getStmtClass() == OMPParallelMaskedDirectiveClass;
2389 bool HasCancel =
false;
2398 llvm::omp::OMPD_parallel_sections, StartLoc,
2405 llvm::omp::OMPD_parallel_sections,
2412 void setHasCancel(
bool Has) { HasCancel = Has; }
2426 static OMPParallelSectionsDirective *
2427 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2428 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
2437 static OMPParallelSectionsDirective *
2438 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2453 return T->
getStmtClass() == OMPParallelSectionsDirectiveClass;
2469 bool HasCancel =
false;
2478 StartLoc, EndLoc) {}
2487 void setHasCancel(
bool Has) { HasCancel = Has; }
2499 static OMPTaskDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2500 SourceLocation EndLoc,
2501 ArrayRef<OMPClause *> Clauses,
2502 Stmt *AssociatedStmt,
bool HasCancel);
2510 static OMPTaskDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
2537 llvm::omp::OMPD_taskyield, StartLoc, EndLoc) {}
2553 static OMPTaskyieldDirective *
2554 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc);
2560 static OMPTaskyieldDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2563 return T->
getStmtClass() == OMPTaskyieldDirectiveClass;
2583 llvm::omp::OMPD_barrier, StartLoc, EndLoc) {}
2599 static OMPBarrierDirective *
2600 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc);
2606 static OMPBarrierDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2629 llvm::omp::OMPD_taskwait, StartLoc, EndLoc) {}
2646 static OMPTaskwaitDirective *
Create(
const ASTContext &
C,
2647 SourceLocation StartLoc,
2648 SourceLocation EndLoc,
2649 ArrayRef<OMPClause *> Clauses);
2656 static OMPTaskwaitDirective *
CreateEmpty(
const ASTContext &
C,
2657 unsigned NumClauses, EmptyShell);
2680 llvm::omp::OMPD_taskgroup, StartLoc, EndLoc) {}
2702 static OMPTaskgroupDirective *
2703 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2704 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2705 Expr *ReductionRef);
2712 static OMPTaskgroupDirective *
CreateEmpty(
const ASTContext &
C,
2713 unsigned NumClauses, EmptyShell);
2723 return T->
getStmtClass() == OMPTaskgroupDirectiveClass;
2747 StartLoc, EndLoc) {}
2764 static OMPFlushDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2765 SourceLocation EndLoc,
2766 ArrayRef<OMPClause *> Clauses);
2774 static OMPFlushDirective *
CreateEmpty(
const ASTContext &
C,
2775 unsigned NumClauses, EmptyShell);
2800 StartLoc, EndLoc) {}
2816 static OMPDepobjDirective *
Create(
const ASTContext &
C,
2817 SourceLocation StartLoc,
2818 SourceLocation EndLoc,
2819 ArrayRef<OMPClause *> Clauses);
2827 static OMPDepobjDirective *
CreateEmpty(
const ASTContext &
C,
2828 unsigned NumClauses, EmptyShell);
2851 llvm::omp::OMPD_ordered, StartLoc, EndLoc) {}
2869 static OMPOrderedDirective *
2870 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2871 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2879 static OMPOrderedDirective *
CreateEmpty(
const ASTContext &
C,
2880 unsigned NumClauses,
2881 bool IsStandalone, EmptyShell);
2909 uint8_t IsXLHSInRHSPart : 1;
2918 uint8_t IsPostfixUpdate : 1;
2921 uint8_t IsFailOnly : 1;
2931 StartLoc, EndLoc) {}
2935 explicit OMPAtomicDirective()
2937 SourceLocation(), SourceLocation()) {}
2939 enum DataPositionTy :
size_t {
2954 void setUpdateExpr(Expr *UE) {
2960 void setR(Expr *R) {
Data->
getChildren()[DataPositionTy::POS_R] = R; }
2962 void setExpr(Expr *E) {
Data->
getChildren()[DataPositionTy::POS_E] = E; }
2964 void setD(Expr *D) {
Data->
getChildren()[DataPositionTy::POS_D] = D; }
3022 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_X]);
3025 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_X]);
3031 return cast_or_null<Expr>(
3035 return cast_or_null<Expr>(
3050 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_V]);
3053 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_V]);
3057 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_R]);
3060 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_R]);
3064 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_E]);
3067 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_E]);
3071 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_D]);
3074 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_D]);
3078 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_Cond]);
3081 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_Cond]);
3107 StartLoc, EndLoc) {}
3124 static OMPTargetDirective *
3125 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3126 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3134 static OMPTargetDirective *
CreateEmpty(
const ASTContext &
C,
3135 unsigned NumClauses, EmptyShell);
3161 llvm::omp::OMPD_target_data, StartLoc, EndLoc) {}
3179 static OMPTargetDataDirective *
3180 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3181 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3188 static OMPTargetDataDirective *
CreateEmpty(
const ASTContext &
C,
unsigned N,
3192 return T->
getStmtClass() == OMPTargetDataDirectiveClass;
3215 llvm::omp::OMPD_target_enter_data, StartLoc,
3222 llvm::omp::OMPD_target_enter_data,
3234 static OMPTargetEnterDataDirective *
3235 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3236 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3243 static OMPTargetEnterDataDirective *
CreateEmpty(
const ASTContext &
C,
3244 unsigned N, EmptyShell);
3247 return T->
getStmtClass() == OMPTargetEnterDataDirectiveClass;
3270 llvm::omp::OMPD_target_exit_data, StartLoc,
3277 llvm::omp::OMPD_target_exit_data,
3289 static OMPTargetExitDataDirective *
3290 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3291 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3298 static OMPTargetExitDataDirective *
CreateEmpty(
const ASTContext &
C,
3299 unsigned N, EmptyShell);
3302 return T->
getStmtClass() == OMPTargetExitDataDirectiveClass;
3318 bool HasCancel =
false;
3327 llvm::omp::OMPD_target_parallel, StartLoc,
3334 llvm::omp::OMPD_target_parallel,
3340 void setHasCancel(
bool Has) { HasCancel = Has; }
3354 static OMPTargetParallelDirective *
3355 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3356 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
3365 static OMPTargetParallelDirective *
3366 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
3381 return T->
getStmtClass() == OMPTargetParallelDirectiveClass;
3399 bool HasCancel =
false;
3408 unsigned CollapsedNum)
3410 llvm::omp::OMPD_target_parallel_for, StartLoc, EndLoc,
3423 void setTaskReductionRefExpr(Expr *E) {
3429 void setHasCancel(
bool Has) { HasCancel = Has; }
3445 static OMPTargetParallelForDirective *
3446 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3447 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3448 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
3458 static OMPTargetParallelForDirective *
CreateEmpty(
const ASTContext &
C,
3459 unsigned NumClauses,
3460 unsigned CollapsedNum,
3477 return T->
getStmtClass() == OMPTargetParallelForDirectiveClass;
3499 StartLoc, EndLoc) {}
3516 static OMPTeamsDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
3517 SourceLocation EndLoc,
3518 ArrayRef<OMPClause *> Clauses,
3519 Stmt *AssociatedStmt);
3527 static OMPTeamsDirective *
CreateEmpty(
const ASTContext &
C,
3528 unsigned NumClauses, EmptyShell);
3554 llvm::omp::OMPD_cancellation_point, StartLoc,
3560 llvm::omp::OMPD_cancellation_point,
3574 static OMPCancellationPointDirective *
3575 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3582 static OMPCancellationPointDirective *
CreateEmpty(
const ASTContext &
C,
3589 return T->
getStmtClass() == OMPCancellationPointDirectiveClass;
3611 StartLoc, EndLoc) {}
3631 static OMPCancelDirective *
3632 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3640 static OMPCancelDirective *
CreateEmpty(
const ASTContext &
C,
3641 unsigned NumClauses, EmptyShell);
3664 bool HasCancel =
false;
3673 unsigned CollapsedNum)
3675 StartLoc, EndLoc, CollapsedNum) {}
3686 void setHasCancel(
bool Has) { HasCancel = Has; }
3700 static OMPTaskLoopDirective *
3701 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3702 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3703 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3712 static OMPTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3713 unsigned NumClauses,
3714 unsigned CollapsedNum, EmptyShell);
3743 unsigned CollapsedNum)
3745 llvm::omp::OMPD_taskloop_simd, StartLoc, EndLoc,
3768 static OMPTaskLoopSimdDirective *
3769 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3770 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3771 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
3780 static OMPTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
3781 unsigned NumClauses,
3782 unsigned CollapsedNum,
3786 return T->
getStmtClass() == OMPTaskLoopSimdDirectiveClass;
3803 bool HasCancel =
false;
3812 unsigned CollapsedNum)
3814 llvm::omp::OMPD_master_taskloop, StartLoc, EndLoc,
3827 void setHasCancel(
bool Has) { HasCancel = Has; }
3841 static OMPMasterTaskLoopDirective *
3842 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3843 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3844 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3853 static OMPMasterTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3854 unsigned NumClauses,
3855 unsigned CollapsedNum,
3862 return T->
getStmtClass() == OMPMasterTaskLoopDirectiveClass;
3879 bool HasCancel =
false;
3888 unsigned CollapsedNum)
3890 llvm::omp::OMPD_masked_taskloop, StartLoc, EndLoc,
3903 void setHasCancel(
bool Has) { HasCancel = Has; }
3917 static OMPMaskedTaskLoopDirective *
3918 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3919 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3920 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3929 static OMPMaskedTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3930 unsigned NumClauses,
3931 unsigned CollapsedNum,
3938 return T->
getStmtClass() == OMPMaskedTaskLoopDirectiveClass;
3961 unsigned CollapsedNum)
3963 llvm::omp::OMPD_master_taskloop_simd, StartLoc, EndLoc,
3986 static OMPMasterTaskLoopSimdDirective *
3987 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3988 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3989 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
3997 static OMPMasterTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
3998 unsigned NumClauses,
3999 unsigned CollapsedNum,
4003 return T->
getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass;
4026 unsigned CollapsedNum)
4028 llvm::omp::OMPD_masked_taskloop_simd, StartLoc, EndLoc,
4051 static OMPMaskedTaskLoopSimdDirective *
4052 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4053 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4054 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4062 static OMPMaskedTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
4063 unsigned NumClauses,
4064 unsigned CollapsedNum,
4068 return T->
getStmtClass() == OMPMaskedTaskLoopSimdDirectiveClass;
4086 bool HasCancel =
false;
4096 unsigned CollapsedNum)
4098 llvm::omp::OMPD_parallel_master_taskloop, StartLoc,
4099 EndLoc, CollapsedNum) {}
4107 llvm::omp::OMPD_parallel_master_taskloop,
4111 void setHasCancel(
bool Has) { HasCancel = Has; }
4125 static OMPParallelMasterTaskLoopDirective *
4126 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4127 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4128 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
4137 static OMPParallelMasterTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
4138 unsigned NumClauses,
4139 unsigned CollapsedNum,
4146 return T->
getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass;
4164 bool HasCancel =
false;
4174 unsigned CollapsedNum)
4176 llvm::omp::OMPD_parallel_masked_taskloop, StartLoc,
4177 EndLoc, CollapsedNum) {}
4185 llvm::omp::OMPD_parallel_masked_taskloop,
4189 void setHasCancel(
bool Has) { HasCancel = Has; }
4203 static OMPParallelMaskedTaskLoopDirective *
4204 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4205 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4206 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
4215 static OMPParallelMaskedTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
4216 unsigned NumClauses,
4217 unsigned CollapsedNum,
4224 return T->
getStmtClass() == OMPParallelMaskedTaskLoopDirectiveClass;
4249 unsigned CollapsedNum)
4251 llvm::omp::OMPD_parallel_master_taskloop_simd,
4252 StartLoc, EndLoc, CollapsedNum) {}
4260 llvm::omp::OMPD_parallel_master_taskloop_simd,
4274 static OMPParallelMasterTaskLoopSimdDirective *
4275 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4276 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4277 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4286 static OMPParallelMasterTaskLoopSimdDirective *
4287 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4291 return T->
getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass;
4316 unsigned CollapsedNum)
4318 llvm::omp::OMPD_parallel_masked_taskloop_simd,
4319 StartLoc, EndLoc, CollapsedNum) {}
4327 llvm::omp::OMPD_parallel_masked_taskloop_simd,
4341 static OMPParallelMaskedTaskLoopSimdDirective *
4342 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4343 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4344 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4353 static OMPParallelMaskedTaskLoopSimdDirective *
4354 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4358 return T->
getStmtClass() == OMPParallelMaskedTaskLoopSimdDirectiveClass;
4381 unsigned CollapsedNum)
4383 llvm::omp::OMPD_distribute, StartLoc, EndLoc,
4406 static OMPDistributeDirective *
4407 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4408 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4409 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4418 static OMPDistributeDirective *
CreateEmpty(
const ASTContext &
C,
4419 unsigned NumClauses,
4420 unsigned CollapsedNum, EmptyShell);
4423 return T->
getStmtClass() == OMPDistributeDirectiveClass;
4446 llvm::omp::OMPD_target_update, StartLoc,
4465 static OMPTargetUpdateDirective *
4466 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4467 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
4475 static OMPTargetUpdateDirective *
CreateEmpty(
const ASTContext &
C,
4476 unsigned NumClauses, EmptyShell);
4479 return T->
getStmtClass() == OMPTargetUpdateDirectiveClass;
4496 bool HasCancel =
false;
4506 unsigned CollapsedNum)
4508 llvm::omp::OMPD_distribute_parallel_for, StartLoc,
4509 EndLoc, CollapsedNum) {}
4517 llvm::omp::OMPD_distribute_parallel_for,
4521 void setTaskReductionRefExpr(Expr *E) {
4527 void setHasCancel(
bool Has) { HasCancel = Has; }
4543 static OMPDistributeParallelForDirective *
4544 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4545 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4546 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
4556 static OMPDistributeParallelForDirective *
CreateEmpty(
const ASTContext &
C,
4557 unsigned NumClauses,
4558 unsigned CollapsedNum,
4575 return T->
getStmtClass() == OMPDistributeParallelForDirectiveClass;
4600 unsigned CollapsedNum)
4602 llvm::omp::OMPD_distribute_parallel_for_simd, StartLoc,
4603 EndLoc, CollapsedNum) {}
4611 llvm::omp::OMPD_distribute_parallel_for_simd,
4625 static OMPDistributeParallelForSimdDirective *
Create(
4626 const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4627 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4628 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4636 static OMPDistributeParallelForSimdDirective *
CreateEmpty(
4637 const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4641 return T->
getStmtClass() == OMPDistributeParallelForSimdDirectiveClass;
4664 unsigned CollapsedNum)
4666 llvm::omp::OMPD_distribute_simd, StartLoc, EndLoc,
4689 static OMPDistributeSimdDirective *
4690 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4691 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4692 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4700 static OMPDistributeSimdDirective *
CreateEmpty(
const ASTContext &
C,
4701 unsigned NumClauses,
4702 unsigned CollapsedNum,
4706 return T->
getStmtClass() == OMPDistributeSimdDirectiveClass;
4731 unsigned CollapsedNum)
4733 llvm::omp::OMPD_target_parallel_for_simd, StartLoc,
4734 EndLoc, CollapsedNum) {}
4742 llvm::omp::OMPD_target_parallel_for_simd,
4756 static OMPTargetParallelForSimdDirective *
4757 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4758 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4759 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4767 static OMPTargetParallelForSimdDirective *
CreateEmpty(
const ASTContext &
C,
4768 unsigned NumClauses,
4769 unsigned CollapsedNum,
4773 return T->
getStmtClass() == OMPTargetParallelForSimdDirectiveClass;
4797 unsigned CollapsedNum)
4799 llvm::omp::OMPD_target_simd, StartLoc, EndLoc,
4822 static OMPTargetSimdDirective *
4823 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4824 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4825 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4833 static OMPTargetSimdDirective *
CreateEmpty(
const ASTContext &
C,
4834 unsigned NumClauses,
4835 unsigned CollapsedNum,
4839 return T->
getStmtClass() == OMPTargetSimdDirectiveClass;
4862 unsigned CollapsedNum)
4864 llvm::omp::OMPD_teams_distribute, StartLoc, EndLoc,